imports method

Implementation

({
  List<ResolvedImport> dart,
  List<ResolvedImport> relative,
  List<ResolvedImport> package,
})
imports({bool trailComments = true}) {
  final path = this.path;

  if (path == null) {
    throw Exception('Path is missing, cannot resolve imports');
  }

  final imports = <String, Reference>{};

  for (final ref in references) {
    final import = ref.import.resolved(path);
    if (import == null) {
      continue;
    }

    final key = switch (ref) {
      Reference(prefix: null) => import,
      Reference(:final String prefix) => '$import as $prefix',
    };

    if (imports.remove(key) case final Reference existing) {
      if (existing.canJoin(ref)) {
        imports[key] = existing.join(ref);
      } else {
        final existingKey = switch (existing) {
          Reference(prefix: null) => import,
          Reference(:final String prefix) => '$import as $prefix',
        };

        if (existingKey == key) {
          throw Exception('Unexpected duplicate import: $key');
        }

        imports[existingKey] = existing;
        imports[key] = ref;
      }
      continue;
    }

    imports[key] = ref;
  }

  final dart = <ResolvedImport>{};
  final relative = <ResolvedImport>{};
  final package = <ResolvedImport>{};

  for (final ref in imports.values) {
    final resolved = ref.importStatement(
      path,
      includeIgnores: !trailComments,
    );
    if (resolved == null) continue;

    void addTo(Set<ResolvedImport> set) {
      set.add(
        ResolvedImport(
          import: resolved,
          trailComments: trailComments,
          ignoreComments: ref.ignores,
        ),
      );
    }

    switch (ref.import) {
      case Import(isDart: true):
        addTo(dart);
      case Import(isRelative: true):
        addTo(relative);
      case Import(isPackage: true):
        addTo(package);
    }
  }

  return (
    dart: dart.toList()..sort(),
    relative: relative.toList()..sort(),
    package: package.toList()..sort(),
  );
}