pkg/front_end/lib/src/kernel/hierarchy/members_builder.dart

// Copyright (c) 2021, 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' show ClassHierarchyMembers;

import '../../builder/declaration_builders.dart';
import '../../builder/formal_parameter_builder.dart';
import '../../builder/type_builder.dart';
import '../../source/source_class_builder.dart';
import 'class_member.dart';
import 'delayed.dart';
import 'extension_type_members.dart';
import 'hierarchy_builder.dart';
import 'members_node.dart';

class ClassMembersBuilder implements ClassHierarchyMembers {
  final ClassHierarchyBuilder hierarchyBuilder;

  final Map<Class, ClassMembersNode> classNodes = new Map.identity();

  final Map<ExtensionTypeDeclaration, ExtensionTypeMembersNode>
  extensionTypeDeclarationNodes = {};

  final List<DelayedTypeComputation> _delayedTypeComputations =
      <DelayedTypeComputation>[];

  final List<DelayedCheck> _delayedChecks = <DelayedCheck>[];

  final List<ClassMember> _delayedMemberComputations = <ClassMember>[];

  ClassMembersBuilder(this.hierarchyBuilder);

  void clear() {
    classNodes.clear();
    _delayedChecks.clear();
    _delayedTypeComputations.clear();
    _delayedMemberComputations.clear();
    extensionTypeDeclarationNodes.clear();
  }

  void registerDelayedTypeComputation(DelayedTypeComputation computation) {
    _delayedTypeComputations.add(computation);
  }

  void registerOverrideCheck(
    SourceClassBuilder classBuilder,
    ClassMember declaredMember,
    Set<ClassMember> overriddenMembers, {
    required ClassMember? localMember,
  }) {
    _delayedChecks.add(
      new DelayedOverrideCheck(
        classBuilder,
        declaredMember,
        overriddenMembers,
        localMember: localMember,
      ),
    );
  }

  void registerGetterSetterCheck(DelayedGetterSetterCheck check) {
    _delayedChecks.add(check);
  }

  void registerMemberComputation(ClassMember member) {
    _delayedMemberComputations.add(member);
  }

  List<DelayedTypeComputation> takeDelayedTypeComputations() {
    List<DelayedTypeComputation> list = _delayedTypeComputations.toList();
    _delayedTypeComputations.clear();
    return list;
  }

  List<DelayedCheck> takeDelayedChecks() {
    List<DelayedCheck> list = _delayedChecks.toList();
    _delayedChecks.clear();
    return list;
  }

  List<ClassMember> takeDelayedMemberComputations() {
    List<ClassMember> list = _delayedMemberComputations.toList();
    _delayedMemberComputations.clear();
    return list;
  }

  void inferFieldType(
    SourceClassBuilder enclosingClassBuilder,
    TypeBuilder declaredFieldType,
    Iterable<ClassMember> overriddenMembers, {
    required String name,
    required Uri fileUri,
    required int nameOffset,
    required int nameLength,
    required bool isAssignable,
  }) {
    ClassMembersNodeBuilder.inferFieldType(
      hierarchyBuilder,
      this,
      enclosingClassBuilder,
      declaredFieldType,
      overriddenMembers,
      name: name,
      fileUri: fileUri,
      nameOffset: nameOffset,
      nameLength: nameLength,
      isAssignable: isAssignable,
    );
  }

  void inferGetterType(
    SourceClassBuilder enclosingClassBuilder,
    TypeBuilder declaredTypeBuilder,
    Iterable<ClassMember> overriddenMembers, {
    required String name,
    required Uri fileUri,
    required int nameOffset,
    required int nameLength,
  }) {
    ClassMembersNodeBuilder.inferGetterType(
      hierarchyBuilder,
      this,
      enclosingClassBuilder,
      declaredTypeBuilder,
      overriddenMembers,
      name: name,
      fileUri: fileUri,
      nameOffset: nameOffset,
      nameLength: nameLength,
    );
  }

  void inferSetterType(
    SourceClassBuilder enclosingClassBuilder,
    List<FormalParameterBuilder>? formals,
    Iterable<ClassMember> overriddenMembers, {
    required String name,
    required Uri fileUri,
    required int nameOffset,
    required int nameLength,
  }) {
    ClassMembersNodeBuilder.inferSetterType(
      hierarchyBuilder,
      this,
      enclosingClassBuilder,
      formals,
      overriddenMembers,
      name: name,
      fileUri: fileUri,
      nameOffset: nameOffset,
      nameLength: nameLength,
    );
  }

  void inferMethodType(
    SourceClassBuilder enclosingClassBuilder,
    FunctionNode declaredFunction,
    TypeBuilder declaredReturnType,
    List<FormalParameterBuilder>? formals,
    Iterable<ClassMember> overriddenMembers, {
    required String name,
    required Uri fileUri,
    required int nameOffset,
    required int nameLength,
  }) {
    ClassMembersNodeBuilder.inferMethodType(
      hierarchyBuilder,
      this,
      enclosingClassBuilder,
      declaredFunction,
      declaredReturnType,
      formals,
      overriddenMembers,
      name: name,
      fileUri: fileUri,
      nameOffset: nameOffset,
      nameLength: nameLength,
    );
  }

  ClassMembersNode getNodeFromClassBuilder(ClassBuilder classBuilder) {
    return classNodes[classBuilder.cls] ??= new ClassMembersNodeBuilder(
      this,
      hierarchyBuilder.getNodeFromClassBuilder(classBuilder),
    ).build();
  }

  ExtensionTypeMembersNode getNodeFromExtensionTypeDeclarationBuilder(
    ExtensionTypeDeclarationBuilder extensionTypeDeclarationBuilder,
  ) {
    return extensionTypeDeclarationNodes[extensionTypeDeclarationBuilder
        .extensionTypeDeclaration] ??= new ExtensionTypeMembersNodeBuilder(
      this,
      hierarchyBuilder.getNodeFromExtensionTypeDeclarationBuilder(
        extensionTypeDeclarationBuilder,
      ),
    ).build();
  }

  ClassMembersNode getNodeFromClass(Class cls) {
    return classNodes[cls] ??
        getNodeFromClassBuilder(
          hierarchyBuilder.loader.computeClassBuilderFromTargetClass(cls),
        );
  }

  ExtensionTypeMembersNode getNodeFromExtensionTypeDeclaration(
    ExtensionTypeDeclaration extensionTypeDeclaration,
  ) {
    return extensionTypeDeclarationNodes[extensionTypeDeclaration] ??
        getNodeFromExtensionTypeDeclarationBuilder(
          hierarchyBuilder.loader
              .computeExtensionTypeBuilderFromTargetExtensionType(
                extensionTypeDeclaration,
              ),
        );
  }

  @override
  Member? getInterfaceMember(Class cls, Name name, {bool setter = false}) {
    return getNodeFromClass(
      cls,
    ).getInterfaceMember(name, setter)?.getMember(this);
  }

  ClassMember? getExtensionTypeClassMember(
    ExtensionTypeDeclaration extensionTypeDeclaration,
    Name name, {
    bool setter = false,
  }) {
    return getNodeFromExtensionTypeDeclaration(
      extensionTypeDeclaration,
    ).getMember(name, setter);
  }

  ClassMember? getExtensionTypeStaticClassMember(
    ExtensionTypeDeclaration extensionTypeDeclaration,
    Name name, {
    bool setter = false,
  }) {
    return getNodeFromExtensionTypeDeclaration(
      extensionTypeDeclaration,
    ).getStaticMember(name, setter);
  }

  @override
  Member? getDispatchTarget(Class cls, Name name, {bool setter = false}) {
    return getNodeFromClass(
      cls,
    ).getDispatchTarget(name, setter)?.getMember(this);
  }

  ClassMember? getDispatchClassMember(
    Class cls,
    Name name, {
    bool setter = false,
  }) {
    return getNodeFromClass(cls).getDispatchTarget(name, setter);
  }

  Member? getStaticMember(Class cls, Name name, {bool setter = false}) {
    return getNodeFromClass(cls).getStaticMember(name, setter)?.getMember(this);
  }

  static ClassMembersBuilder build(
    ClassHierarchyBuilder hierarchyBuilder,
    List<ClassBuilder> classes,
    List<ExtensionTypeDeclarationBuilder> extensionTypeDeclarations,
  ) {
    ClassMembersBuilder membersBuilder = new ClassMembersBuilder(
      hierarchyBuilder,
    );
    for (ClassBuilder classBuilder in classes) {
      membersBuilder.getNodeFromClassBuilder(classBuilder);
    }
    for (ExtensionTypeDeclarationBuilder extensionTypeDeclarationBuilder
        in extensionTypeDeclarations) {
      membersBuilder.getNodeFromExtensionTypeDeclarationBuilder(
        extensionTypeDeclarationBuilder,
      );
    }
    return membersBuilder;
  }

  void computeTypes() {
    List<DelayedTypeComputation> typeComputations =
        takeDelayedTypeComputations();
    for (int i = 0; i < typeComputations.length; i++) {
      typeComputations[i].compute(this);
    }
  }
}

int compareNamedParameters(VariableDeclaration a, VariableDeclaration b) {
  return a.name!.compareTo(b.name!);
}