generateClass method

Future<ClassDeclaration> generateClass(
  1. ClassMirror classMirror,
  2. Package package,
  3. String libraryUri,
  4. Uri sourceUri,
)

Generate class declaration with integrated analyzer support

Implementation

Future<ClassDeclaration> generateClass(mirrors.ClassMirror classMirror, Package package, String libraryUri, Uri sourceUri) async {
  final className = mirrors.MirrorSystem.getName(classMirror.simpleName);

  // Get runtime type with fallback and safety check
  Type runtimeType = classMirror.hasReflectedType ? classMirror.reflectedType : classMirror.runtimeType;

  // Get analyzer element and type
  final classElement = await _getClassElement(className, sourceUri);
  final dartType = classElement?.thisType;

  final annotations = await _extractAnnotations(classMirror.metadata, package);

  // Resolve type from @Generic annotation if needed
  if(GenericTypeParser.shouldCheckGeneric(runtimeType)) {
    final resolvedType = await _resolveTypeFromGenericAnnotation(annotations, className);
    if (resolvedType != null) {
      runtimeType = resolvedType;
    }
  }

  final constructors = <ConstructorDeclaration>[];
  final fields = <FieldDeclaration>[];
  final methods = <MethodDeclaration>[];
  final records = <RecordDeclaration>[];

  // Get source code for modifier detection
  String? sourceCode = _sourceCache[sourceUri.toString()];

  // Extract inheritance relationships using LinkDeclarations
  final supertype = await _extractSupertypeAsLink(classMirror, classElement, package, libraryUri);
  final interfaces = await _extractInterfacesAsLink(classMirror, classElement, package, libraryUri);
  final mixins = await _extractMixinsAsLink(classMirror, classElement, package, libraryUri);

  // Create class declaration with full analyzer integration
  StandardClassDeclaration reflectedClass = StandardClassDeclaration(
    name: className,
    type: runtimeType,
    element: classElement,
    dartType: dartType,
    qualifiedName: _buildQualifiedName(className, (classMirror.location?.sourceUri ?? Uri.parse(libraryUri)).toString()),
    parentLibrary: _libraryCache[libraryUri]!,
    isNullable: false,
    typeArguments: await _extractTypeArgumentsAsLinks(classMirror.typeVariables, classElement?.typeParameters, package, libraryUri),
    annotations: annotations,
    sourceLocation: sourceUri,
    superClass: supertype,
    interfaces: interfaces,
    mixins: mixins,
    isAbstract: classMirror.isAbstract,
    isMixin: _isMixinClass(sourceCode, className),
    isSealed: _isSealedClass(sourceCode, className),
    isBase: _isBaseClass(sourceCode, className),
    isInterface: _isInterfaceClass(sourceCode, className),
    isFinal: _isFinalClass(sourceCode, className),
    isPublic: !_isInternal(className),
    isSynthetic: _isSynthetic(className),
    isRecord: false,
  );

  _typeCache[runtimeType] = reflectedClass;

  // Process constructors with analyzer support
  for (final constructor in classMirror.declarations.values.whereType<mirrors.MethodMirror>()) {
    if (constructor.isConstructor) {
      constructors.add(await generateConstructor(constructor, classElement, package, libraryUri, sourceUri, className, reflectedClass));
    }
  }

  // Process fields with analyzer support
  for (final field in classMirror.declarations.values.whereType<mirrors.VariableMirror>()) {
    fields.add(await generateField(field, classElement, package, libraryUri, sourceUri, className, reflectedClass, sourceCode));
  }

  // Process methods with analyzer support
  for (final method in classMirror.declarations.values.whereType<mirrors.MethodMirror>()) {
    if (!method.isConstructor && !method.isAbstract) {
      methods.add(await generateMethod(method, classElement, package, libraryUri, sourceUri, className, reflectedClass));
    }
  }

  return reflectedClass.copyWith(constructors: constructors, fields: fields, methods: methods, records: records);
}