pkg/front_end/lib/src/dill/dill_class_builder.dart

// Copyright (c) 2017, 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 'package:kernel/ast.dart';
import 'package:kernel/class_hierarchy.dart';

import '../api_prototype/lowering_predicates.dart';
import '../base/loader.dart';
import '../base/lookup_result.dart';
import '../base/name_space.dart';
import '../base/scope.dart';
import '../builder/declaration_builders.dart';
import '../builder/library_builder.dart';
import '../builder/member_builder.dart';
import '../builder/type_builder.dart';
import 'dill_library_builder.dart' show DillLibraryBuilder;
import 'dill_member_builder.dart';
import 'dill_type_parameter_builder.dart';

class DillClassBuilder extends ClassBuilderImpl {
  @override
  final DillLibraryBuilder parent;

  @override
  final Class cls;

  late final DeclarationNameSpace _nameSpace;

  final List<MemberBuilder> _constructorBuilders = [];
  final List<MemberBuilder> _memberBuilders = [];

  List<NominalParameterBuilder>? _typeParameters;

  TypeBuilder? _supertypeBuilder;

  List<TypeBuilder>? _interfaceBuilders;

  DillClassBuilder(this.cls, this.parent) {
    Map<String, MemberLookupResult> constructors = {};
    Map<String, MemberLookupResult> content = {};
    Map<String, Procedure> tearOffs = {};
    List<Procedure> nonTearOffs = [];
    for (Procedure procedure in cls.procedures) {
      String? name = extractConstructorNameFromTearOff(procedure.name);
      if (name != null) {
        tearOffs[name] = procedure;
      } else {
        nonTearOffs.add(procedure);
      }
    }

    bool _isPrivateFromOtherLibrary(Member member) {
      Name name = member.name;
      return name.isPrivate &&
          name.libraryReference != cls.enclosingLibrary.reference;
    }

    for (Procedure procedure in nonTearOffs) {
      String name = procedure.name.text;
      switch (procedure.kind) {
        case ProcedureKind.Factory:
          Procedure? factoryTearOff = tearOffs[procedure.name.text];
          DillFactoryBuilder builder = new DillFactoryBuilder(
              procedure, factoryTearOff, libraryBuilder, this);
          if (!_isPrivateFromOtherLibrary(procedure)) {
            assert(
                !constructors.containsKey(name),
                "Unexpected existing member ${constructors[name]}, "
                "trying to add $builder.");
            constructors[name] = builder;
          }
          _constructorBuilders.add(builder);
        case ProcedureKind.Setter:
          DillSetterBuilder builder =
              new DillSetterBuilder(procedure, libraryBuilder, this);
          if (!_isPrivateFromOtherLibrary(procedure)) {
            MemberLookupResult? existing = content[name];
            if (existing != null) {
              assert(
                  existing.getable != null && existing.setable == null,
                  "Unexpected existing member $existing, "
                  "trying to add $builder.");
              assert(
                  existing.isStatic == builder.isStatic,
                  "Static/instance conflict between existing member $existing "
                  "and new builder $builder.");
              content[name] = new GetableSetableMemberResult(
                  existing.getable!, builder,
                  isStatic: existing.isStatic);
            } else {
              content[name] = builder;
            }
          }
          _memberBuilders.add(builder);
        case ProcedureKind.Getter:
          DillGetterBuilder builder =
              new DillGetterBuilder(procedure, libraryBuilder, this);
          if (!_isPrivateFromOtherLibrary(procedure)) {
            MemberLookupResult? existing = content[name];
            if (existing != null) {
              assert(
                  existing.getable == null && existing.setable != null,
                  "Unexpected existing member $existing, "
                  "trying to add $builder.");
              assert(
                  existing.isStatic == builder.isStatic,
                  "Static/instance conflict between existing member $existing "
                  "and new builder $builder.");
              content[name] = new GetableSetableMemberResult(
                  builder, existing.setable!,
                  isStatic: existing.isStatic);
            } else {
              content[name] = builder;
            }
          }
          _memberBuilders.add(builder);
        case ProcedureKind.Operator:
          DillOperatorBuilder builder =
              new DillOperatorBuilder(procedure, libraryBuilder, this);
          if (!_isPrivateFromOtherLibrary(procedure)) {
            assert(
                !content.containsKey(name),
                "Unexpected existing member ${content[name]}, "
                "trying to add $builder.");
            content[name] = builder;
          }
          _memberBuilders.add(builder);
        case ProcedureKind.Method:
          DillMethodBuilder builder =
              new DillMethodBuilder(procedure, libraryBuilder, this);
          if (!_isPrivateFromOtherLibrary(procedure)) {
            assert(
                !content.containsKey(name),
                "Unexpected existing member ${content[name]}, "
                "trying to add $builder.");
            content[name] = builder;
          }
          _memberBuilders.add(builder);
      }
    }

    for (Constructor constructor in cls.constructors) {
      String name = constructor.name.text;
      Procedure? constructorTearOff = tearOffs[name];
      DillConstructorBuilder builder = new DillConstructorBuilder(
          constructor, constructorTearOff, libraryBuilder, this);
      if (!_isPrivateFromOtherLibrary(constructor)) {
        assert(
            !constructors.containsKey(name),
            "Unexpected existing member ${constructors[name]}, "
            "trying to add $builder.");
        constructors[name] = builder;
      }
      _constructorBuilders.add(builder);
    }

    for (Field field in cls.fields) {
      String name = field.name.text;
      DillFieldBuilder builder =
          new DillFieldBuilder(field, libraryBuilder, this);
      if (!_isPrivateFromOtherLibrary(field)) {
        MemberLookupResult? existing = content[name];
        if (existing != null) {
          assert(
              existing.getable == null && existing.setable != null,
              "Unexpected existing member $existing, "
              "trying to add $builder.");
          assert(
              existing.isStatic == builder.isStatic,
              "Static/instance conflict between existing member $existing "
              "and new builder $builder.");
          content[name] = new GetableSetableMemberResult(
              builder, existing.setable!,
              isStatic: existing.isStatic);
        } else {
          content[name] = builder;
        }
      }
      _memberBuilders.add(builder);
    }
    _nameSpace = new DillDeclarationNameSpace(
        constructors: constructors, content: content);
  }

  @override
  int get fileOffset => cls.fileOffset;

  @override
  String get name => cls.name;

  @override
  Uri get fileUri => cls.fileUri;

  @override
  DeclarationNameSpace get nameSpace => _nameSpace;

  @override
  bool get isEnum => cls.isEnum;

  @override
  DillLibraryBuilder get libraryBuilder =>
      super.libraryBuilder as DillLibraryBuilder;

  @override
  bool get isMixinClass => cls.isMixinClass;

  @override
  bool get isMixinDeclaration => cls.isMixinDeclaration;

  @override
  bool get isSealed => cls.isSealed;

  @override
  bool get isBase => cls.isBase;

  @override
  bool get isInterface => cls.isInterface;

  @override
  bool get isFinal => cls.isFinal;

  @override
  bool get isAbstract => cls.isAbstract;

  @override
  bool get isNamedMixinApplication => cls.isMixinApplication;

  @override
  // Coverage-ignore(suite): Not run.
  Iterator<MemberBuilder> get unfilteredMembersIterator =>
      _memberBuilders.iterator;

  @override
  Iterator<T> filteredMembersIterator<T extends MemberBuilder>(
          {required bool includeDuplicates}) =>
      new FilteredIterator<T>(_memberBuilders.iterator,
          includeDuplicates: includeDuplicates);

  @override
  // Coverage-ignore(suite): Not run.
  Iterator<MemberBuilder> get unfilteredConstructorsIterator =>
      _constructorBuilders.iterator;

  @override
  Iterator<T> filteredConstructorsIterator<T extends MemberBuilder>(
          {required bool includeDuplicates}) =>
      new FilteredIterator<T>(_constructorBuilders.iterator,
          includeDuplicates: includeDuplicates);

  @override
  List<NominalParameterBuilder>? get typeParameters {
    List<NominalParameterBuilder>? typeParameters = _typeParameters;
    if (typeParameters == null && cls.typeParameters.isNotEmpty) {
      typeParameters = _typeParameters = computeTypeParameterBuilders(
          cls.typeParameters, libraryBuilder.loader);
    }
    return typeParameters;
  }

  @override
  TypeBuilder? get supertypeBuilder {
    TypeBuilder? supertype = _supertypeBuilder;
    if (supertype == null) {
      Supertype? targetSupertype = cls.supertype;
      if (targetSupertype == null) return null;
      _supertypeBuilder =
          supertype = computeTypeBuilder(libraryBuilder, targetSupertype);
    }
    return supertype;
  }

  @override
  int get typeParametersCount => cls.typeParameters.length;

  @override
  List<DartType> buildAliasedTypeArguments(LibraryBuilder library,
      List<TypeBuilder>? arguments, ClassHierarchyBase? hierarchy) {
    // For performance reasons, [typeParameters] aren't restored from [target].
    // So, if [arguments] is null, the default types should be retrieved from
    // [cls.typeParameters].
    if (arguments == null) {
      // TODO(johnniwinther): Use i2b here when needed.
      return new List<DartType>.generate(cls.typeParameters.length,
          (int i) => cls.typeParameters[i].defaultType,
          growable: true);
    }

    // [arguments] != null
    return new List<DartType>.generate(
        arguments.length,
        (int i) =>
            arguments[i].buildAliased(library, TypeUse.typeArgument, hierarchy),
        growable: true);
  }

  /// Returns true if this class is the result of applying a mixin to its
  /// superclass.
  @override
  bool get isMixinApplication => cls.isMixinApplication;

  @override
  // Coverage-ignore(suite): Not run.
  bool get declaresConstConstructor => cls.hasConstConstructor;

  @override
  TypeBuilder? get mixedInTypeBuilder {
    return computeTypeBuilder(libraryBuilder, cls.mixedInType);
  }

  @override
  List<TypeBuilder>? get interfaceBuilders {
    if (cls.implementedTypes.isEmpty) return null;
    List<TypeBuilder>? interfaceBuilders = _interfaceBuilders;
    if (interfaceBuilders == null) {
      interfaceBuilders = _interfaceBuilders = new List<TypeBuilder>.generate(
          cls.implementedTypes.length,
          (int i) =>
              computeTypeBuilder(libraryBuilder, cls.implementedTypes[i])!,
          growable: false);
    }
    return interfaceBuilders;
  }

  void clearCachedValues() {
    _supertypeBuilder = null;
    _interfaceBuilders = null;
    _typeParameters = null;
  }

  @override
  Reference get reference => cls.reference;
}

TypeBuilder? computeTypeBuilder(
    DillLibraryBuilder library, Supertype? supertype) {
  return supertype == null
      ? null
      : library.loader.computeTypeBuilder(supertype.asInterfaceType);
}

List<DillNominalParameterBuilder>? computeTypeParameterBuilders(
    List<TypeParameter>? typeParameters, Loader loader) {
  if (typeParameters == null || typeParameters.length == 0) return null;
  return <DillNominalParameterBuilder>[
    for (TypeParameter typeParameter in typeParameters)
      new DillNominalParameterBuilder(typeParameter, loader: loader)
  ];
}