code: public <T> DynamicType.Builder<T> redefine(TypeDescription type, ClassFileLocator classFileLocator) {
          if (type.isArray() || type.isPrimitive()) {
              throw new IllegalArgumentException("Cannot redefine array or primitive type: " + type);
          }
          return new RedefinitionDynamicTypeBuilder<T>(instrumentedTypeFactory.represent(type),
                  classFileVersion,
                  auxiliaryTypeNamingStrategy,
                  annotationValueFilterFactory,
                  annotationRetention,
                  implementationContextFactory,
                  methodGraphCompiler,
                  typeValidation,
                  visibilityBridgeStrategy,
                  classWriterStrategy,
                  ignoredMethods,
                  type,
                  classFileLocator);
      }
docs: <p>
  Redefines the given type where any intercepted method that is declared by the redefined type is fully replaced
  by the new implementation.
  </p>
  <p>
  <b>Note</b>: When a user redefines a class with the purpose of reloading this class using a {@link net.bytebuddy.dynamic.loading.ClassReloadingStrategy},
  it is important that no fields or methods are added to the redefined class. Note that some {@link Implementation}s implicitly add fields or methods.
  Finally, Byte Buddy might be forced to add a method if a redefined class already defines a class initializer. This can be disabled by setting
  {@link ByteBuddy#with(Implementation.Context.Factory)} to use a {@link net.bytebuddy.implementation.Implementation.Context.Disabled.Factory}
  where the class initializer is retained <i>as is</i>.
  </p>
  
  @param type             The type that is being redefined.
  @param classFileLocator The class file locator that is queried for the redefined type's class file.
  @param <T>              The loaded type of the redefined type.
  @return A type builder for redefining the provided type.