pkg/_fe_analyzer_shared/lib/src/metadata/scope.dart

// Copyright (c) 2024, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'proto.dart';
import 'references.dart';
import 'type_annotations.dart';

/// Scope used to lookup named entities.
abstract class Scope {
  /// Returns the [Proto] corresponding to [name] in this scope.
  ///
  /// This might be an [UnresolvedIdentifier] if [name] was not found in this
  /// scope.
  Proto lookup(String name);
}

/// Scope of a type declaration used to lookup static members.
abstract class TypeDeclarationScope {
  /// Returns the [Proto] corresponding to accessing [name] on the type
  /// declaration.
  ///
  /// If the access is preceded by [typeArguments], these must be passed and
  /// included in the returned [Proto].
  Proto lookup(String name, [List<TypeAnnotation>? typeArguments]);
}

/// Base implementation for creating a [TypeDeclarationScope] for a class.
abstract base class BaseClassScope implements TypeDeclarationScope {
  ClassReference get classReference;

  Proto createConstructorProto(List<TypeAnnotation>? typeArguments,
      ConstructorReference constructorReference) {
    return new ConstructorProto(
        classReference, typeArguments ?? const [], constructorReference);
  }

  Proto createMemberProto<T>(List<TypeAnnotation>? typeArguments, String name,
      T? member, Proto Function(T, String) memberToProto) {
    if (member == null) {
      if (typeArguments != null) {
        return new UnresolvedAccess(
            new GenericClassProto(classReference, this, typeArguments), name);
      } else {
        return new UnresolvedAccess(new ClassProto(classReference, this), name);
      }
    } else {
      if (typeArguments != null) {
        return new InvalidAccessProto(
            new GenericClassProto(classReference, this, typeArguments), name);
      } else {
        return memberToProto(member, name);
      }
    }
  }
}

/// Base implementation for creating a [TypeDeclarationScope] for an extension.
abstract base class BaseExtensionScope implements TypeDeclarationScope {
  ExtensionReference get extensionReference;

  Proto createMemberProto<T>(List<TypeAnnotation>? typeArguments, String name,
      T? member, Proto Function(T, String) memberToProto) {
    if (typeArguments != null) {
      return new UnresolvedAccess(
          new InvalidInstantiationProto(
              new ExtensionProto(extensionReference, this), typeArguments),
          name);
    } else if (member == null) {
      return new UnresolvedAccess(
          new ExtensionProto(extensionReference, this), name);
    } else {
      return memberToProto(member, name);
    }
  }
}

/// Base implementation for creating a [TypeDeclarationScope] for an extension
/// type.
abstract base class BaseExtensionTypeScope implements TypeDeclarationScope {
  ExtensionTypeReference get extensionTypeReference;

  Proto createConstructorProto(List<TypeAnnotation>? typeArguments,
      ConstructorReference constructorReference) {
    return new ConstructorProto(extensionTypeReference,
        typeArguments ?? const [], constructorReference);
  }

  Proto createMemberProto<T>(List<TypeAnnotation>? typeArguments, String name,
      T? member, Proto Function(T, String) memberToProto) {
    if (member == null) {
      if (typeArguments != null) {
        return new UnresolvedAccess(
            new GenericExtensionTypeProto(
                extensionTypeReference, this, typeArguments),
            name);
      } else {
        return new UnresolvedAccess(
            new ExtensionTypeProto(extensionTypeReference, this), name);
      }
    } else {
      if (typeArguments != null) {
        return new InvalidAccessProto(
            new GenericExtensionTypeProto(
                extensionTypeReference, this, typeArguments),
            name);
      } else {
        return memberToProto(member, name);
      }
    }
  }
}

/// Base implementation for creating a [TypeDeclarationScope] for an enum.
abstract base class BaseEnumScope implements TypeDeclarationScope {
  EnumReference get enumReference;

  // TODO(johnniwinther): Support constructor lookup to support full parsing.

  Proto createMemberProto<T>(List<TypeAnnotation>? typeArguments, String name,
      T? member, Proto Function(T, String) memberToProto) {
    if (member == null) {
      if (typeArguments != null) {
        return new UnresolvedAccess(
            new GenericEnumProto(enumReference, this, typeArguments), name);
      } else {
        return new UnresolvedAccess(new EnumProto(enumReference, this), name);
      }
    } else {
      if (typeArguments != null) {
        return new InvalidAccessProto(
            new GenericEnumProto(enumReference, this, typeArguments), name);
      } else {
        return memberToProto(member, name);
      }
    }
  }
}

/// Base implementation for creating a [TypeDeclarationScope] for a mixin.
abstract base class BaseMixinScope implements TypeDeclarationScope {
  MixinReference get mixinReference;

  Proto createMemberProto<T>(List<TypeAnnotation>? typeArguments, String name,
      T? member, Proto Function(T, String) memberToProto) {
    if (member == null) {
      if (typeArguments != null) {
        return new UnresolvedAccess(
            new GenericMixinProto(mixinReference, this, typeArguments), name);
      } else {
        return new UnresolvedAccess(new MixinProto(mixinReference, this), name);
      }
    } else {
      if (typeArguments != null) {
        return new InvalidAccessProto(
            new GenericMixinProto(mixinReference, this, typeArguments), name);
      } else {
        return memberToProto(member, name);
      }
    }
  }
}

/// Base implementation for creating a [TypeDeclarationScope] for a typedef.
abstract base class BaseTypedefScope implements TypeDeclarationScope {
  TypedefReference get typedefReference;

  Proto createConstructorProto(List<TypeAnnotation>? typeArguments,
      ConstructorReference constructorReference) {
    return new ConstructorProto(
        typedefReference, typeArguments ?? const [], constructorReference);
  }

  Proto createMemberProto(List<TypeAnnotation>? typeArguments, String name) {
    if (typeArguments != null) {
      return new UnresolvedAccess(
          new GenericTypedefProto(typedefReference, this, typeArguments), name);
    } else {
      return new UnresolvedAccess(
          new TypedefProto(typedefReference, this), name);
    }
  }
}