Allow linked types to refer to local executables.

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

 // Copyright (c) 2015, 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.
 
 library summary_resynthesizer;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 660 matching lines @@
   @override
   String get displayName => name;
 
   @override
   ClassElement get enclosingElement {
     return _definingType.element;
   }
 }
 
 /**
+ * Local function element representing the intializer for a variable that has
+ * been resynthesized from a summary.  The actual element won't be constructed
+ * until it is requested.  But properties [context] and [enclosingElement] can
+ * be used without creating the actual element.
+ */
+class _DeferredInitializerElement extends FunctionElementHandle {
+  /**
+   * The variable element containing this element.
+   */
+  final VariableElement _enclosingElement;

[scheglov, 2016/02/18 21:53:51]

We could do

@override
final VariableElement enclosingElement;

...and remove the getter.

[Paul Berry, 2016/02/18 22:14:23]

Done.

+
+  _DeferredInitializerElement(this._enclosingElement) : super(null, null);
+
+  @override
+  FunctionElement get actualElement => _enclosingElement.initializer;
+
+  @override
+  AnalysisContext get context => _enclosingElement.context;
+
+  @override
+  VariableElement get enclosingElement => _enclosingElement;
+
+  @override
+  ElementLocation get location => actualElement.location;
+}
+
+/**
+ * Local function element that has been resynthesized from a summary.  The
+ * actual element won't be constructed until it is requested.  But properties
+ * [context] and [enclosingElement] can be used without creating the actual
+ * element.
+ */
+class _DeferredLocalFunctionElement extends FunctionElementHandle {
+  /**
+   * The executable element containing this element.
+   */
+  final ExecutableElement _enclosingElement;
+
+  /**
+   * The index of this function within [ExecutableElement.functions].
+   */
+  final int _localIndex;
+
+  _DeferredLocalFunctionElement(this._enclosingElement, this._localIndex)
+      : super(null, null);
+
+  @override
+  FunctionElement get actualElement {
+    ExecutableElement enclosingElement = _enclosingElement;
+    if (enclosingElement is PropertyAccessorElement && enclosingElement.isSynthetic) {
+      return enclosingElement.variable.initializer;
+    } else {
+      return _enclosingElement.functions[_localIndex];
+    }
+  }
+
+  @override
+  AnalysisContext get context => _enclosingElement.context;
+
+  @override
+  ExecutableElement get enclosingElement => _enclosingElement;
+
+  @override
+  ElementLocation get location => actualElement.location;
+}
+
+/**
+ * Local variable element that has been resynthesized from a summary.  The
+ * actual element won't be constructed until it is requested.  But properties
+ * [context] and [enclosingElement] can be used without creating the actual
+ * element.
+ */
+class _DeferredLocalVariableElement extends LocalVariableElementHandle {
+  /**
+   * The executable element containing this element.
+   */
+  final ExecutableElement _enclosingElement;
+
+  /**
+   * The index of this variable within [ExecutableElement.localVariables].
+   */
+  final int _localIndex;
+
+  _DeferredLocalVariableElement(this._enclosingElement, this._localIndex)
+      : super(null, null);
+
+  @override
+  LocalVariableElement get actualElement =>
+      _enclosingElement.localVariables[_localIndex];
+
+  @override
+  AnalysisContext get context => _enclosingElement.context;
+
+  @override
+  ExecutableElement get enclosingElement => _enclosingElement;
+
+  @override
+  ElementLocation get location => actualElement.location;
+}
+
+/**
  * An instance of [_LibraryResynthesizer] is responsible for resynthesizing the
  * elements in a single library from that library's summary.
  */
 class _LibraryResynthesizer {
   /**
    * The [SummaryResynthesizer] which is being used to obtain summaries.
    */
   final SummaryResynthesizer summaryResynthesizer;
 
   /**
@@ skipping 523 matching lines @@
       case ReferenceKind.topLevelPropertyAccessor:
         return new PropertyAccessorElementHandle(
             summaryResynthesizer, location);
       case ReferenceKind.constructor:
       case ReferenceKind.function:
       case ReferenceKind.propertyAccessor:
       case ReferenceKind.method:
       case ReferenceKind.length:
       case ReferenceKind.prefix:
       case ReferenceKind.unresolved:
+      case ReferenceKind.variable:
         // Should never happen.  Exported names never refer to import prefixes,
         // and they always refer to defined top-level entities.
         throw new StateError('Unexpected export name kind: ${exportName.kind}');
     }
   }
 
   /**
    * Build the export namespace for the library by aggregating together its
    * [publicNamespace] and [exportNames].
    */
@@ skipping 707 matching lines @@
             element = new FunctionElementHandle(summaryResynthesizer, location);
             break;
           case ReferenceKind.topLevelPropertyAccessor:
             element = new PropertyAccessorElementHandle(
                 summaryResynthesizer, location);
             break;
           case ReferenceKind.typedef:
             element = new FunctionTypeAliasElementHandle(
                 summaryResynthesizer, location);
             break;
+          case ReferenceKind.variable:
+            Element enclosingElement = enclosingInfo.element;
+            if (enclosingElement is ExecutableElement) {
+              element = new _DeferredLocalVariableElement(
+                  enclosingElement, linkedReference.localIndex);
+            } else {
+              throw new StateError('Unexpected element enclosing variable:'
+                  ' ${enclosingElement.runtimeType}');
+            }
+            break;
           case ReferenceKind.function:
+            Element enclosingElement = enclosingInfo.element;
+            if (enclosingElement is VariableElement) {
+              element = new _DeferredInitializerElement(enclosingElement);
+            } else if (enclosingElement is ExecutableElement) {
+              element = new _DeferredLocalFunctionElement(
+                  enclosingElement, linkedReference.localIndex);
+            } else {
+              throw new StateError('Unexpected element enclosing function:'
+                  ' ${enclosingElement.runtimeType}');
+            }
+            break;
           case ReferenceKind.prefix:
           case ReferenceKind.unresolved:
             break;
         }
       }
       referenceInfos[i] = new _ReferenceInfo(
           enclosingInfo, name, element, type, numTypeParameters);
     }
   }
 
@@ skipping 268 matching lines @@
                 }
               : () => this.element;
       // TODO(paulberry): Is it a bug that we have to pass `false` for
       // isInstantiated?
       return new DeferredFunctionTypeImpl(computer, null, typeArguments, false);
     } else {
       return null;
     }
   }
 }