Add preliminary local function reference support to the AST summary linker.

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 952 matching lines @@
       LinkedReference linkedReference = _linkedUnit.references[index];
       String name = unlinkedReference == null
           ? linkedReference.name
           : unlinkedReference.name;
       int containingReference = unlinkedReference == null
           ? linkedReference.containingReference
           : unlinkedReference.prefixReference;
       if (containingReference != 0 &&
           _linkedUnit.references[containingReference].kind !=
               ReferenceKind.prefix) {
-        _references[index] =
-            _resolveRef(containingReference).getContainedName(name);
+        if (linkedReference.kind == ReferenceKind.function) {
+          // Local function
+          _references[index] = _resolveRef(containingReference)
+              .getLocalFunction(linkedReference.localIndex);
+        } else {
+          _references[index] =
+              _resolveRef(containingReference).getContainedName(name);
+        }
       } else if (linkedReference.dependency == 0) {
         if (name == 'void') {
           _references[index] = enclosingElement._linker.voidElement;
         } else if (name == '*bottom*') {
           _references[index] = enclosingElement._linker.bottomElement;
         } else if (name == 'dynamic') {
           _references[index] = enclosingElement._linker.dynamicElement;
         } else {
           _references[index] = enclosingElement.getContainedName(name);
         }
@@ skipping 134 matching lines @@
       return addRawReference(element.name,
           dependency: library.addDependency(element.library),
           numTypeParameters: element.typeParameters.length,
           unitNum: element.enclosingElement.unitNum);
     } else if (element is FunctionTypeAliasElementForLink) {
       return addRawReference(element.name,
           dependency: library.addDependency(element.library),
           numTypeParameters: element.typeParameters.length,
           unitNum: element.enclosingElement.unitNum,
           kind: ReferenceKind.typedef);
+    } else if (element is FunctionElementForLink_Initializer) {
+      return addRawReference('',
+          containingReference: addReference(element.enclosingElement),
+          kind: ReferenceKind.function,
+          localIndex: 0);
+    } else if (element is FunctionElementForLink_Local_NonSynthetic) {
+      ExecutableElementForLink parent = element.enclosingElement;
+      int localIndex = parent.functions.indexOf(element);
+      assert(localIndex != -1);
+      return addRawReference(element.name,
+          containingReference: addReference(parent),
+          kind: ReferenceKind.function,
+          localIndex: localIndex);
     } else if (element is ExecutableElementForLink_NonLocal) {
       ClassElementForLink_Class enclosingClass = element.enclosingClass;
       ReferenceKind kind;
       switch (element._unlinkedExecutable.kind) {
         case UnlinkedExecutableKind.functionOrMethod:
           kind = enclosingClass != null
               ? ReferenceKind.method
               : ReferenceKind.topLevelFunction;
           break;
         case UnlinkedExecutableKind.setter:
           kind = ReferenceKind.propertyAccessor;
           break;
         default:
           // TODO(paulberry): implement other cases as necessary
           throw new UnimplementedError('${element._unlinkedExecutable.kind}');
       }
       return addRawReference(element.name,
           numTypeParameters: element.typeParameters.length,
           containingReference:
               enclosingClass != null ? addReference(enclosingClass) : null,
           dependency: enclosingClass != null
               ? null
               : library.addDependency(element.library),
           kind: kind);
-    } else if (element is FunctionElementForLink_Local) {
-      FunctionElementImpl parent = element.enclosingElement;
-      int localIndex = parent.functions.indexOf(element);
-      assert(localIndex != -1);
-      return addRawReference(element.name,
-          containingReference: addReference(parent),
-          kind: ReferenceKind.function,
-          localIndex: localIndex);
     } else if (element is FunctionElementForLink_Initializer) {
       return addRawReference('',
           containingReference: addReference(element.enclosingElement),
           kind: ReferenceKind.function);
     } else if (element is TopLevelVariableElementForLink) {
       return addRawReference(element.name,
           dependency: library.addDependency(element.library),
           kind: ReferenceKind.topLevelPropertyAccessor);
     } else if (element is FieldElementForLink_ClassField) {
       ClassElementForLink_Class enclosingClass = element.enclosingElement;
@@ skipping 1535 matching lines @@
   @override
   List<TypeParameterElement> get typeParameters => const [];
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Element representing the initializer expression of a variable.
  */
-class FunctionElementForLink_Initializer implements FunctionElementImpl {
+class FunctionElementForLink_Initializer extends Object
+    with ReferenceableElementForLink
+    implements FunctionElementForLink_Local {
   /**
    * The variable for which this element is the initializer.
    */
   final VariableElementForLink _variable;
 
-  List<FunctionElementForLink_Local> _functions;
+  List<FunctionElementForLink_Local_NonSynthetic> _functions;
 
   FunctionElementForLink_Initializer(this._variable);
 
   @override
   VariableElementForLink get enclosingElement => _variable;
 
+  TypeParameterizedElementForLink get enclosingTypeParameterContext =>
+      _variable.enclosingElement is ClassElementForLink
+          ? _variable.enclosingElement
+          : null;
+
   @override
-  List<FunctionElementForLink_Local> get functions => _functions ??= _variable
-      .unlinkedVariable.initializer.localFunctions
-      .map((UnlinkedExecutable ex) =>
-          new FunctionElementForLink_Local(_variable.compilationUnit, this, ex))
-      .toList();
+  List<FunctionElementForLink_Local_NonSynthetic> get functions =>
+      _functions ??= _variable.unlinkedVariable.initializer.localFunctions
+          .map((UnlinkedExecutable ex) =>
+              new FunctionElementForLink_Local_NonSynthetic(
+                  _variable.compilationUnit, this, ex))
+          .toList();
 
   @override
   DartType get returnType {
     // If this is a variable whose type needs inferring, infer it.
     if (_variable.hasImplicitType) {
       return _variable.inferredType;
     } else {
       // There's no reason linking should need to access the type of
       // this FunctionElement, since the variable doesn't need its
       // type inferred.
       assert(false);
       // But for robustness, return the dynamic type.
       return DynamicTypeImpl.instance;
     }
   }
 
   @override
   void set returnType(DartType newType) {
     // InstanceMemberInferrer stores the new type both here and on the variable
     // element.  We don't need to record both values, so we ignore it here.
   }
 
   @override
+  int get typeParameterNestingLevel =>
+      enclosingTypeParameterContext?.typeParameterNestingLevel ?? 0;
+
+  List<TypeParameterElement> get typeParameters => const [];
+
+  @override
+  FunctionElementForLink_Local getLocalFunction(int index) {
+    List<FunctionElementForLink_Local_NonSynthetic> functions = this.functions;
+    return index < functions.length ? functions[index] : null;
+  }
+
+  @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
+ * Element representing a local function (possibly a closure).
+ */
+abstract class FunctionElementForLink_Local
+    implements
+        ExecutableElementForLink,
+        FunctionElementImpl,
+        ReferenceableElementForLink {}
+
+/**
  * Element representing a local function (possibly a closure) inside another
  * executable.
  */
-class FunctionElementForLink_Local extends ExecutableElementForLink
-    implements FunctionElementImpl {
+class FunctionElementForLink_Local_NonSynthetic extends ExecutableElementForLink
+    with ReferenceableElementForLink
+    implements FunctionElementForLink_Local {
   @override
-  final FunctionElementImpl enclosingElement;
+  final ExecutableElementForLink enclosingElement;
 
-  FunctionElementForLink_Local(CompilationUnitElementForLink compilationUnit,
-      this.enclosingElement, UnlinkedExecutable unlinkedExecutable)
+  FunctionElementForLink_Local_NonSynthetic(
+      CompilationUnitElementForLink compilationUnit,
+      this.enclosingElement,
+      UnlinkedExecutable unlinkedExecutable)
       : super(compilationUnit, unlinkedExecutable);
 
   @override
+  TypeParameterizedElementForLink get enclosingTypeParameterContext =>
+      enclosingElement;
+
+  @override
+  DartType buildType(
+      DartType getTypeArgument(int i), List<int> implicitFunctionTypeIndices) {
+    assert(implicitFunctionTypeIndices.isEmpty);
+    return type;
+  }
+
+  @override
+  FunctionElementForLink_Local getLocalFunction(int index) {
+    // TODO(paulberry): implement.
+    throw new UnimplementedError();
+  }
+
+  @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Element representing a typedef resynthesized from a summary during linking.
  */
 class FunctionTypeAliasElementForLink extends Object
     with
         TypeParameterizedElementForLink,
         ParameterParentElementForLink,
@@ skipping 628 matching lines @@
   @override
   DartType get asStaticType => type;
 
   @override
   String get identifier => name;
 
   @override
   ElementKind get kind => ElementKind.METHOD;
 
   @override
+  FunctionElementForLink_Local getLocalFunction(int index) {
+    // TODO(paulberry): implement.
+    return null;
+  }
+
+  @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }
 
 /**
  * Instances of [Node] represent nodes in a dependency graph.  The
  * type parameter, [NodeType], is the derived type (this affords some
  * extra type safety by making it difficult to accidentally construct
@@ skipping 340 matching lines @@
 
   @override
   List<TypeParameterElement> get typeParameters => const [];
 
   @override
   ReferenceableElementForLink getContainedName(String name) {
     return new NonstaticMemberElementForLink(library, this, name);
   }
 
   @override
+  FunctionElementForLink_Local getLocalFunction(int index) {
+    // TODO(paulberry): implement (should return the synthetic function element
+    // for the enum field's initializer).
+    return null;
+  }
+
+  @override
   bool isAccessibleIn(LibraryElement library) =>
       !Identifier.isPrivateName(name) || identical(this.library, library);
 
   @override
   void link(CompilationUnitElementInBuildUnit compilationUnit) {}
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
@@ skipping 36 matching lines @@
   @override
   ElementKind get kind => _unlinkedExecutable.kind ==
       UnlinkedExecutableKind.getter ? ElementKind.GETTER : ElementKind.SETTER;
 
   @override
   ReferenceableElementForLink getContainedName(String name) {
     return new NonstaticMemberElementForLink(library, this, name);
   }
 
   @override
+  FunctionElementForLink_Local getLocalFunction(int index) {
+    // TODO(paulberry): implement
+    return null;
+  }
+
+  @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }
 
 /**
  * Specialization of [PropertyAccessorElementForLink] for synthetic accessors
  * implied by a field or variable declaration.
  */
@@ skipping 86 matching lines @@
       return variable.type;
     }
   }
 
   @override
   ReferenceableElementForLink getContainedName(String name) {
     return new NonstaticMemberElementForLink(library, this, name);
   }
 
   @override
+  FunctionElementForLink_Local getLocalFunction(int index) {
+    if (index == 0) {
+      return variable.initializer;
+    } else {
+      return null;
+    }
+  }
+
+  @override
   bool isAccessibleIn(LibraryElement library) =>
       !Identifier.isPrivateName(name) || identical(this.library, library);
 
   @override
   void link(CompilationUnitElementInBuildUnit compilationUnit) {}
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }
 
 /**
  * Base class representing an element which can be the target of a reference.
  * When used as a mixin, implements the default behavior shared by most
  * elements.
  */
-abstract class ReferenceableElementForLink {
+class ReferenceableElementForLink {
   /**
    * If this element can be used in a constructor invocation context,
    * return the associated constructor (which may be `this` or some
    * other element).  Otherwise return `null`.
    */
   ConstructorElementForLink get asConstructor => null;
 
   /**
    * If this element can be used in a getter context to refer to a
    * constant variable, return the [ConstVariableNode] for the
@@ skipping 27 matching lines @@
    * If this element contains other named elements, return the
    * contained element having the given [name].  If this element can't
    * contain other named elements, or it doesn't contain an element
    * with the given name, return the singleton of
    * [UndefinedElementForLink].
    */
   ReferenceableElementForLink getContainedName(String name) {
     // TODO(paulberry): handle references to `call` for function types.
     return UndefinedElementForLink.instance;
   }
+
+  /**
+   * If this element contains local functions, return the contained local
+   * function having the given [index].  If this element doesn't contain local
+   * functions, or the index is out of range, return `null`.
+   */
+  FunctionElementForLink_Local getLocalFunction(int index) => null;
 }
 
 /**
  * Element used for references to special types such as `void`.
  */
 class SpecialTypeElementForLink extends Object
     with ReferenceableElementForLink {
   final Linker linker;
   final DartType type;
 
@@ skipping 45 matching lines @@
       CompilationUnitElementForLink enclosingUnit, UnlinkedExecutable _buf)
       : super(enclosingUnit, null, _buf);
 
   @override
   DartType get asStaticType => type;
 
   @override
   ElementKind get kind => ElementKind.FUNCTION;
 
   @override
+  FunctionElementForLink_Local getLocalFunction(int index) {
+    // TODO(paulberry): implement.
+    return null;
+  }
+
+  @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Element representing a top level variable resynthesized from a
  * summary during linking.
  */
 class TopLevelVariableElementForLink extends VariableElementForLink
     implements TopLevelVariableElement {
   TopLevelVariableElementForLink(CompilationUnitElementForLink enclosingElement,
@@ skipping 589 matching lines @@
    * there are no type parameters in scope.
    */
   TypeParameterizedElementForLink get _typeParameterContext;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }