generateLibrary method

Future<LibraryDeclaration> generateLibrary(
  1. LibraryMirror libraryMirror
)

Generate library declaration with integrated analyzer support

Implementation

Future<LibraryDeclaration> generateLibrary(mirrors.LibraryMirror libraryMirror) async {
  // Clear processing caches for this library
  _clearProcessingCaches();

  final uri = libraryMirror.uri.toString();
  final packageName = getPackageNameFromUri(uri);
  final package = _packageCache[packageName] ?? _createDefaultPackage(packageName ?? "unknown");

  // Get analyzer library element
  final libraryElement = await _getLibraryElement(libraryMirror.uri);

  // Create library declaration with analyzer support
  final currentLibrary = StandardLibraryDeclaration(
    uri: uri,
    element: libraryElement,
    parentPackage: package,
    declarations: [],
    isPublic: !_isInternal(uri),
    isSynthetic: _isSynthetic(uri),
    annotations: await _extractAnnotations(libraryMirror.metadata, package),
    sourceLocation: libraryMirror.uri,
  );

  _libraryCache[uri] = currentLibrary;
  final declarations = <SourceDeclaration>[];

  // Process classes and mixins
  for (final classMirror in libraryMirror.declarations.values.whereType<mirrors.ClassMirror>()) {
    final fileUri = classMirror.location?.sourceUri ?? libraryMirror.uri;
    if (await shouldNotIncludeLibrary(fileUri, configuration) || isSkippableJetLeafPackage(fileUri)) {
      continue;
    }

    Type typeToReflect = classMirror.hasReflectedType ? classMirror.reflectedType : classMirror.runtimeType;

    if(GenericTypeParser.shouldCheckGeneric(typeToReflect)) {
      final annotations = await _extractAnnotations(classMirror.metadata, package);
      final resolvedType = await _resolveTypeFromGenericAnnotation(annotations, mirrors.MirrorSystem.getName(classMirror.simpleName));
      if (resolvedType != null) {
        typeToReflect = resolvedType;
      }
    }

    if (configuration.scanClasses.isNotEmpty && !configuration.scanClasses.contains(typeToReflect)) {
      continue;
    }

    if (configuration.excludeClasses.contains(typeToReflect)) {
      continue;
    }

    String? fileContent;
    try {
      fileContent = await _readSourceCode(fileUri);
      if ((isTest(fileContent) && configuration.skipTests) || hasMirrorImport(fileContent)) {
        continue;
      }
    } catch (e) {
      onError('Could not read file content for $fileUri: $e');
      continue;
    }

    if (classMirror.isEnum) {
      declarations.add(await generateEnum(classMirror, package, uri, fileUri));
    } else if (_isMixinClass(fileContent, mirrors.MirrorSystem.getName(classMirror.simpleName))) {
      declarations.add(await generateMixin(classMirror, package, uri, fileUri));
    } else {
      declarations.add(await generateClass(classMirror, package, uri, fileUri));
    }
  }

  // Process typedefs
  for (final typedefMirror in libraryMirror.declarations.values.whereType<mirrors.TypedefMirror>()) {
    final name = mirrors.MirrorSystem.getName(typedefMirror.simpleName);
    if (_isInternal(name) || _isSynthetic(name)) continue;

    final fileUri = typedefMirror.location?.sourceUri ?? libraryMirror.uri;
    if (await shouldNotIncludeLibrary(fileUri, configuration) || isSkippableJetLeafPackage(fileUri)) {
      continue;
    }

    String? fileContent;
    try {
      fileContent = await _readSourceCode(fileUri);
      if ((isTest(fileContent) && configuration.skipTests) || hasMirrorImport(fileContent)) {
        continue;
      }
    } catch (e) {
      onError('Could not read file content for $fileUri: $e');
      continue;
    }

    declarations.add(await generateTypedef(typedefMirror, package, uri, fileUri));
  }

  // Process top-level functions and variables
  for (final declaration in libraryMirror.declarations.values) {
    final name = mirrors.MirrorSystem.getName(declaration.simpleName);
    if (_isInternal(name) || _isSynthetic(name)) continue;

    final fileUri = declaration.location?.sourceUri ?? libraryMirror.uri;
    if (await shouldNotIncludeLibrary(fileUri, configuration) || isSkippableJetLeafPackage(fileUri)) {
      continue;
    }

    String? fileContent;
    try {
      fileContent = await _readSourceCode(fileUri);
      if ((isTest(fileContent) && configuration.skipTests) || hasMirrorImport(fileContent)) {
        continue;
      }
    } catch (e) {
      onError('Could not read file content for $fileUri: $e');
      continue;
    }

    if (declaration is mirrors.MethodMirror && !declaration.isConstructor && !declaration.isAbstract) {
      declarations.add(await generateTopLevelMethod(declaration, package, uri, fileUri));
    } else if (declaration is mirrors.VariableMirror) {
      declarations.add(await generateTopLevelField(declaration, package, uri, fileUri));
    }
  }

  return currentLibrary.copyWith(declarations: declarations);
}