Fix a corner case of AST-based type inference with sequences of identifiers separated by '.'.

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 3234 matching lines @@
   /**
    * Compute the dependencies of this node.
    */
   List<NodeType> computeDependencies();
 }
 
 /**
  * Element used for references that result from trying to access a non-static
  * member of an element that is not a container (e.g. accessing the "length"
  * property of a constant).
+ *
+ * Also handles accesses to a chain of non-static members separated by '.'.
  */
 class NonstaticMemberElementForLink implements ReferenceableElementForLink {
   /**
-   * The non-static element of this link element.
+   * The static variable element from which the non-static member access begins.
    */
-  final Element element;
+  final VariableElementForLink _variable;
 
   /**
-   * If the thing from which a member was accessed is a constant, the
-   * associated [ConstNode].  Otherwise `null`.
+   * The list of non-static members that are accessed.
    */
-  final ConstVariableNode _constNode;
+  final List<String> _names;
 
-  NonstaticMemberElementForLink(this.element, this._constNode);
+  /**
+   * The library in which the access occurs.  This determines whether private
+   * names are accessible.
+   */
+  final LibraryElementForLink _library;
+
+  NonstaticMemberElementForLink(this._library, this._variable, this._names);
 
   @override
   ConstructorElementForLink get asConstructor => null;
 
   @override
-  ConstVariableNode get asConstVariable => _constNode;
+  ConstVariableNode get asConstVariable => _variable._constNode;
 
   @override
   DartType get asStaticType {
-    Element element = this.element;
-    if (element is PropertyAccessorElement) {
-      if (element.isGetter) {
-        return element.returnType;
+    if (_library._linker.strongMode) {
+      DartType type = _variable.asStaticType;
+      for (String name in _names) {
+        type = _typeLookupStep(type, name);
       }
-      return DynamicTypeImpl.instance;
+      return type;
     }
-    if (element is MethodElement) {
-      return element.type;
-    }
+    // TODO(paulberry, scheglov): implement for propagated types
     return DynamicTypeImpl.instance;
   }
 
   @override
-  TypeInferenceNode get asTypeInferenceNode {
-    // TODO(paulberry): implement.
-    return null;
-  }
+  TypeInferenceNode get asTypeInferenceNode => _variable._typeInferenceNode;
 
   @override
   DartType buildType(DartType getTypeArgument(int i),
           List<int> implicitFunctionTypeIndices) =>
       DynamicTypeImpl.instance;
 
   @override
   ReferenceableElementForLink getContainedName(String name) {
-    if (element != null) {
-      DartType type = asStaticType;
-      if (type is InterfaceType) {
-        Element nameElement = type.lookUpGetter(name, element.library);
-        nameElement ??= type.lookUpMethod(name, element.library);
-        return new NonstaticMemberElementForLink(nameElement, _constNode);
+    return new NonstaticMemberElementForLink(
+        _library, _variable, _names.toList()..add(name));
+  }
+
+  /**
+   * Perform a single step in the resolution of the non-static access, looking
+   * up in [type] for the nonstatic entity having the given [name].  Return the
+   * type of the entity that was found, or `dynamic` if no entity was found.
+   */
+  DartType _typeLookupStep(DartType type, String name) {
+    if (type is InterfaceType) {
+      PropertyAccessorElement getter = type.lookUpGetter(name, _library);
+      if (getter != null) {
+        return getter.returnType;
+      }
+      MethodElement method = type.lookUpMethod(name, _library);
+      if (method != null) {
+        return method.type;
       }
     }
-    return this;
+    // TODO(paulberry): handle .call on function types and .toString or .hashCode on all types.
+    return DynamicTypeImpl.instance;
   }
 }
 
 /**
  * Element representing a function or method parameter resynthesized
  * from a summary during linking.
  */
 class ParameterElementForLink implements ParameterElementImpl {
   /**
    * The unlinked representation of the parameter in the summary.
@@ skipping 333 matching lines @@
       // (even if we have already computed it), since that would lead to
       // non-deterministic type inference results.
       return DynamicTypeImpl.instance;
     } else {
       return variable.type;
     }
   }
 
   @override
   ReferenceableElementForLink getContainedName(String name) {
-    Element element = variable._getContainedElement(name);
-    return new NonstaticMemberElementForLink(element, variable._constNode);
+    return new NonstaticMemberElementForLink(library, variable, <String>[name]);
   }
 
   @override
   bool isAccessibleIn(LibraryElement library) =>
       !Identifier.isPrivateName(name) || identical(this.library, library);
 
   @override
   void link(CompilationUnitElementInBuildUnit compilationUnit) {}
 
   @override
@@ skipping 150 matching lines @@
   @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(CompilationUnitElement enclosingElement,
+  TopLevelVariableElementForLink(CompilationUnitElementForLink enclosingElement,
       UnlinkedVariable unlinkedVariable)
       : super(unlinkedVariable, enclosingElement);
 
   @override
   bool get isStatic => true;
 
   @override
+  LibraryElementForLink get library => compilationUnit.library;
+
+  @override
   TypeParameterizedElementForLink get _typeParameterContext => null;
 
   /**
    * Store the results of type inference for this variable in
    * [compilationUnit].
    */
   void link(CompilationUnitElementInBuildUnit compilationUnit) {
     if (hasImplicitType) {
       TypeInferenceNode typeInferenceNode = this.asTypeInferenceNode;
       if (typeInferenceNode != null) {
@@ skipping 561 matching lines @@
    * there are no type parameters in scope.
    */
   TypeParameterizedElementForLink get _typeParameterContext;
 
   @override
   DartType buildType(DartType getTypeArgument(int i),
           List<int> implicitFunctionTypeIndices) =>
       DynamicTypeImpl.instance;
 
   ReferenceableElementForLink getContainedName(String name) {
-    Element element = _getContainedElement(name);
-    return new NonstaticMemberElementForLink(element, _constNode);
+    return new NonstaticMemberElementForLink(library, this, <String>[name]);
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
-
-  /**
-   * Return the contained element with the given [name], or `null` if the lookup
-   * fails.  Currently only static types are supported in the linker, so lookup
-   * is performed only in the strong mode.
-   */
-  Element _getContainedElement(String name) {
-    Linker linker = compilationUnit.library._linker;
-    if (linker.strongMode) {
-      DartType type = asStaticType;
-      if (type is InterfaceType) {
-        Element result = type.lookUpGetter(name, compilationUnit.library);
-        result ??= type.lookUpMethod(name, compilationUnit.library);
-        return result;
-      }
-    }
-    // TODO(scheglov): implement for propagated types
-    return null;
-  }
 }