code: public <T> DynamicType.Builder<T> rebase(TypeDescription type, ClassFileLocator classFileLocator, MethodNameTransformer methodNameTransformer) {
          if (type.isArray() || type.isPrimitive()) {
              throw new IllegalArgumentException("Cannot rebase array or primitive type: " + type);
          }
          return new RebaseDynamicTypeBuilder<T>(instrumentedTypeFactory.represent(type),
                  classFileVersion,
                  auxiliaryTypeNamingStrategy,
                  annotationValueFilterFactory,
                  annotationRetention,
                  implementationContextFactory,
                  methodGraphCompiler,
                  typeValidation,
                  visibilityBridgeStrategy,
                  classWriterStrategy,
                  ignoredMethods,
                  type,
                  classFileLocator,
                  methodNameTransformer);
      }
docs: Rebases the given type where any intercepted method that is declared by the redefined type is preserved within the
  rebased type's class such that the class's original can be invoked from the new method implementations. Rebasing a
  type can be seen similarly to creating a subclass where the subclass is later merged with the original class file.
  
  @param type                  The type that is being rebased.
  @param classFileLocator      The class file locator that is queried for the rebased type's class file.
  @param methodNameTransformer The method name transformer for renaming a method that is rebased.
  @param <T>                   The loaded type of the rebased type.
  @return A type builder for rebasing the provided type.