pkg/analyzer/lib/src/summary2/default_value_resolver.dart

// Copyright (c) 2019, 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:analyzer/dart/element/scope.dart';
import 'package:analyzer/src/dart/ast/ast.dart';
import 'package:analyzer/src/dart/element/element.dart';
import 'package:analyzer/src/dart/element/type_system.dart';
import 'package:analyzer/src/summary2/ast_resolver.dart';
import 'package:analyzer/src/summary2/library_builder.dart';
import 'package:analyzer/src/summary2/link.dart';
import 'package:analyzer/src/summary2/linking_node_scope.dart';
import 'package:analyzer/src/utilities/extensions/element.dart';

class DefaultValueResolver {
  final Linker _linker;
  final LibraryBuilder _libraryBuilder;
  final TypeSystemImpl _typeSystem;

  DefaultValueResolver(this._linker, this._libraryBuilder)
    : _typeSystem = _libraryBuilder.element.typeSystem;

  void resolve() {
    for (var libraryFragment in _libraryBuilder.element.fragments) {
      _UnitContext(libraryFragment)
        ..forEach(libraryFragment.classes, _interface)
        ..forEach(libraryFragment.enums, _interface)
        ..forEach(libraryFragment.extensions, _extension)
        ..forEach(libraryFragment.extensionTypes, _interface)
        ..forEach(libraryFragment.functions, _executable)
        ..forEach(libraryFragment.mixins, _interface);
    }
  }

  void _constructor(_ClassContext context, ConstructorFragmentImpl element) {
    if (element.isSynthetic) return;
    _executable(context, element);
  }

  DefaultFormalParameterImpl? _defaultParameter(
    FormalParameterFragmentImpl element,
  ) {
    var node = _linker.getLinkingNode(element);
    if (node is DefaultFormalParameterImpl && node.defaultValue != null) {
      return node;
    } else {
      return null;
    }
  }

  void _executable(_Context context, ExecutableFragmentImpl element) {
    _ExecutableContext(
      enclosingContext: context,
      executableElement: element,
      scope: _scopeFromElement(element),
    ).forEach(element.parameters, _parameter);
  }

  void _extension(_UnitContext context, ExtensionFragmentImpl element) {
    context.forEach(element.methods, _executable);
  }

  void _interface(_UnitContext context, InterfaceFragmentImpl element) {
    _ClassContext(context, element)
      ..forEach(element.constructors, _constructor)
      ..forEach(element.methods, _executable);
  }

  void _parameter(
    _ExecutableContext context,
    FormalParameterFragmentImpl parameter,
  ) {
    // If a function typed parameter, process nested parameters.
    context.forEach(parameter.parameters, _parameter);

    var node = _defaultParameter(parameter);
    if (node == null) return;

    var contextType = _typeSystem.eliminateTypeVariables(parameter.type);

    var analysisOptions = _libraryBuilder.kind.file.analysisOptions;
    var astResolver = AstResolver(
      _linker,
      context.libraryFragment,
      context.scope,
      analysisOptions,
      enclosingClassElement: context.classElement?.asElement2,
      enclosingExecutableElement: context.executableElement.asElement2,
    );
    astResolver.resolveExpression(
      () => node.defaultValue!,
      contextType: contextType,
    );
  }

  Scope _scopeFromElement(FragmentImpl element) {
    var node = _linker.getLinkingNode(element)!;
    return LinkingNodeContext.get(node).scope;
  }
}

class _ClassContext extends _Context {
  final _UnitContext unitContext;

  @override
  final InterfaceFragmentImpl classElement;

  _ClassContext(this.unitContext, this.classElement);

  @override
  LibraryFragmentImpl get libraryFragment {
    return unitContext.libraryFragment;
  }
}

abstract class _Context {
  InterfaceFragmentImpl? get classElement => null;

  LibraryFragmentImpl get libraryFragment;
}

class _ExecutableContext extends _Context {
  final _Context enclosingContext;
  final ExecutableFragmentImpl executableElement;
  final Scope scope;

  _ExecutableContext({
    required this.enclosingContext,
    required this.executableElement,
    required this.scope,
  });

  @override
  InterfaceFragmentImpl? get classElement {
    return enclosingContext.classElement;
  }

  @override
  LibraryFragmentImpl get libraryFragment {
    return enclosingContext.libraryFragment;
  }
}

class _UnitContext extends _Context {
  @override
  final LibraryFragmentImpl libraryFragment;

  _UnitContext(this.libraryFragment);
}

extension _ContextExtension<C extends _Context> on C {
  void forEach<T>(List<T> elements, void Function(C context, T element) f) {
    for (var element in elements) {
      f(this, element);
    }
  }
}