generateEnum method

Future<EnumDeclaration> generateEnum(
  1. ClassMirror enumMirror,
  2. Package package,
  3. String libraryUri,
  4. Uri sourceUri,
)

Generate enum declaration with analyzer support

Implementation

Future<EnumDeclaration> generateEnum(mirrors.ClassMirror enumMirror, Package package, String libraryUri, Uri sourceUri) async {
  final enumName = mirrors.MirrorSystem.getName(enumMirror.simpleName);
  final enumElement = await _getEnumElement(enumName, sourceUri);
  final dartType = enumElement?.thisType;

  final values = <EnumFieldDeclaration>[];
  final members = <MemberDeclaration>[];

  Type runtimeType = enumMirror.hasReflectedType ? enumMirror.reflectedType : enumMirror.runtimeType;

  // Extract annotations and resolve type
  if(GenericTypeParser.shouldCheckGeneric(runtimeType)) {
    final annotations = await _extractAnnotations(enumMirror.metadata, package);
    final resolvedType = await _resolveTypeFromGenericAnnotation(annotations, enumName);
    if (resolvedType != null) {
      runtimeType = resolvedType;
    }
  }

  StandardEnumDeclaration reflectedEnum = StandardEnumDeclaration(
    name: enumName,
    type: runtimeType,
    element: enumElement,
    dartType: dartType,
    isPublic: !_isInternal(enumName),
    isSynthetic: _isSynthetic(enumName),
    qualifiedName: _buildQualifiedName(enumName, (enumMirror.location?.sourceUri ?? Uri.parse(libraryUri)).toString()),
    parentLibrary: _libraryCache[libraryUri]!,
    values: values,
    isNullable: false,
    typeArguments: await _extractTypeArgumentsAsLinks(enumMirror.typeVariables, enumElement?.typeParameters, package, libraryUri),
    annotations: await _extractAnnotations(enumMirror.metadata, package),
    sourceLocation: sourceUri,
    members: members,
  );

  // Extract enum values with safety checks
  for (final declaration in enumMirror.declarations.values) {
    if (declaration is mirrors.VariableMirror && declaration.isStatic && declaration.type.hasReflectedType && declaration.type.reflectedType == runtimeType) {
      final fieldMirror = enumMirror.getField(declaration.simpleName);
      if (fieldMirror.hasReflectee) {
        final enumFieldName = mirrors.MirrorSystem.getName(declaration.simpleName);

        values.add(StandardEnumFieldDeclaration(
          name: enumFieldName,
          type: runtimeType,
          libraryDeclaration: _libraryCache[libraryUri]!,
          value: fieldMirror.reflectee,
          isPublic: !_isInternal(enumFieldName),
          isSynthetic: _isSynthetic(enumFieldName),
          position: enumMirror.declarations.values.toList().indexOf(declaration),
          isNullable: _isNullable(fieldName: enumFieldName, sourceCode: await _readSourceCode(sourceUri))
        ));
      }
    }
  }

  // Extract enum methods and fields
  for (final declaration in enumMirror.declarations.values) {
    if (declaration is mirrors.MethodMirror && !declaration.isConstructor) {
      members.add(await generateMethod(declaration, enumElement, package, libraryUri, sourceUri, enumName, null));
    } else if (declaration is mirrors.VariableMirror && !declaration.isStatic) {
      members.add(await generateField(declaration, enumElement, package, libraryUri, sourceUri, enumName, null, null));
    }
  }

  reflectedEnum = reflectedEnum.copyWith(values: values, members: members);

  _typeCache[runtimeType] = reflectedEnum;
  return reflectedEnum;
}