generateClass method
Future<ClassDeclaration>
generateClass(
- ClassMirror classMirror,
- Package package,
- String libraryUri,
- 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);
}