Add LibraryElementForLink.context getter.

pkg/analyzer/lib/src/summary/link.dart

 // Copyright (c) 2016, 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.
 
 /**
  * This library is capable of producing linked summaries from unlinked
  * ones (or prelinked ones).  It functions by building a miniature
  * element model to represent the contents of the summaries, and then
  * scanning the element model to gather linked information and adding
  * it to the summary data structures.
@@ skipping 46 matching lines @@
  * - Where possible, we favor method dispatch instead of "is" and "as"
  *   checks.  E.g. see [ReferenceableElementForLink.asConstructor].
  */
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' show TokenType;
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/constant/value.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
+import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/prelink.dart';
 import 'package:analyzer/src/task/strong_mode.dart';
 
 bool isIncrementOrDecrement(UnlinkedExprAssignOperator operator) {
   switch (operator) {
     case UnlinkedExprAssignOperator.prefixDecrement:
@@ skipping 1326 matching lines @@
     List<ConstNode> dependencies = <ConstNode>[];
     collectDependencies(
         dependencies,
         variableElement.unlinkedVariable.constExpr,
         variableElement.compilationUnit);
     return dependencies;
   }
 }
 
 /**
+ * Stub implementation of [AnalysisContext] which provides just those methods
+ * needed during linking.
+ */
+class ContextForLink implements AnalysisContext {
+  final Linker _linker;
+
+  ContextForLink(this._linker);
+
+  @override
+  TypeSystem get typeSystem => _linker.typeSystem;
+
+  @override
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+/**
  * An instance of [DependencyWalker] contains the core algorithms for
  * walking a dependency graph and evaluating nodes in a safe order.
  */
 abstract class DependencyWalker<NodeType extends Node<NodeType>> {
   /**
    * Called by [walk] to evaluate a single non-cyclical node, after
    * all that node's dependencies have been evaluated.
    */
   void evaluate(NodeType v);
 
@@ skipping 123 matching lines @@
    * The unlinked representation of the method in the summary.
    */
   final UnlinkedExecutable _unlinkedExecutable;
 
   DartType _declaredReturnType;
   DartType _inferredReturnType;
   FunctionTypeImpl _type;
   List<TypeParameterElementForLink> _typeParameters;
   String _name;
   List<ParameterElementForLink> _parameters;
+  String _displayName;
 
   /**
    * TODO(paulberry): this won't always be a class element.
    */
   @override
   final ClassElementForLink_Class enclosingElement;
 
   ExecutableElementForLink(this.enclosingElement, this._unlinkedExecutable);
 
   /**
    * Return the compilation unit in which this executable appears.
    */
   CompilationUnitElementForLink get compilationUnit =>
       enclosingElement.enclosingElement;
 
   @override
+  String get displayName {
+    if (_displayName == null) {
+      _displayName = _unlinkedExecutable.name;
+      if (_unlinkedExecutable.kind == UnlinkedExecutableKind.setter) {
+        _displayName = _displayName.substring(0, _displayName.length - 1);
+      }
+    }
+    return _displayName;
+  }
+
+  @override
   TypeParameterizedElementForLink get enclosingTypeParameterContext =>
       enclosingElement;
 
   @override
   bool get hasImplicitReturnType => _unlinkedExecutable.returnType == null;
 
   @override
   bool get isStatic => _unlinkedExecutable.isStatic;
 
   @override
@@ skipping 1064 matching lines @@
   UnlinkedUnit _definingUnlinkedUnit;
   List<LibraryElementForLink> _importedLibraries;
   List<LibraryElementForLink> _exportedLibraries;
 
   LibraryElementForLink(this._linker, this._absoluteUri) {
     if (_linkedLibrary != null) {
       _dependencies.length = _linkedLibrary.dependencies.length;
     }
   }
 
+  @override
+  ContextForLink get context => _linker.context;
+
   /**
    * Get the [UnlinkedUnit] for the defining compilation unit of this library.
    */
   UnlinkedUnit get definingUnlinkedUnit =>
       _definingUnlinkedUnit ??= _linker.getUnit(_absoluteUri.toString());
 
   @override
   Element get enclosingElement => null;
 
   @override
@@ skipping 261 matching lines @@
    */
   final bool strongMode;
 
   LibraryElementForLink _coreLibrary;
   LibraryElementForLink _asyncLibrary;
   TypeProviderForLink _typeProvider;
   TypeSystem _typeSystem;
   SpecialTypeElementForLink _voidElement;
   SpecialTypeElementForLink _dynamicElement;
   SpecialTypeElementForLink _bottomElement;
+  ContextForLink _context;
 
   Linker(Map<String, LinkedLibraryBuilder> linkedLibraries, this.getDependency,
       this.getUnit, this.strongMode) {
     // Create elements for the libraries to be linked.  The rest of
     // the element model will be created on demand.
     linkedLibraries
         .forEach((String absoluteUri, LinkedLibraryBuilder linkedLibrary) {
       Uri uri = Uri.parse(absoluteUri);
       _librariesInBuildUnit.add(_libraries[uri] =
           new LibraryElementInBuildUnit(this, uri, linkedLibrary));
     });
   }
 
   /**
    * Get the library element for `dart:async`.
    */
   LibraryElementForLink get asyncLibrary =>
       _asyncLibrary ??= getLibrary(Uri.parse('dart:async'));
 
   /**
    * Get the element representing the "bottom" type.
    */
   SpecialTypeElementForLink get bottomElement => _bottomElement ??=
       new SpecialTypeElementForLink(this, BottomTypeImpl.instance);
 
   /**
+   * Get a stub implementation of [AnalysisContext] which can be used during
+   * linking.
+   */
+  get context => _context ??= new ContextForLink(this);
+
+  /**
    * Get the library element for `dart:core`.
    */
   LibraryElementForLink get coreLibrary =>
       _coreLibrary ??= getLibrary(Uri.parse('dart:core'));
 
   /**
    * Get the element representing `dynamic`.
    */
   SpecialTypeElementForLink get dynamicElement => _dynamicElement ??=
       new SpecialTypeElementForLink(this, DynamicTypeImpl.instance);
@@ skipping 1061 matching lines @@
           List<int> implicitFunctionTypeIndices) =>
       DynamicTypeImpl.instance;
 
   ReferenceableElementForLink getContainedName(String name) {
     return new NonstaticMemberElementForLink(_constNode);
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }