Support for a.b.c.d extract property sequence.

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 3106 matching lines @@
    */
   bool get isEvaluated;
 
   /**
    * Compute the dependencies of this node.
    */
   List<NodeType> computeDependencies();
 }
 
 /**
- * Element used for references that result from trying to access a nonstatic
+ * 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).
  */
 class NonstaticMemberElementForLink implements ReferenceableElementForLink {
   /**
+   * The non-static element of this link element.
+   */
+  final Element element;
+
+  /**
    * If the thing from which a member was accessed is a constant, the
    * associated [ConstNode].  Otherwise `null`.
    */
   final ConstVariableNode _constNode;
 
-  NonstaticMemberElementForLink(this._constNode);
+  NonstaticMemberElementForLink(this.element, this._constNode);
 
   @override
   ConstructorElementForLink get asConstructor => null;
 
   @override
   ConstVariableNode get asConstVariable => _constNode;
 
   @override
   DartType get asStaticType {
+    Element element = this.element;
+    if (element is PropertyAccessorElement && element.isGetter) {
+      return element.returnType;
+    }
     // TODO(paulberry): implement.
     return DynamicTypeImpl.instance;
   }
 
   @override
   TypeInferenceNode get asTypeInferenceNode {
     // TODO(paulberry): implement.
     return null;
   }
 
   @override
   DartType buildType(DartType getTypeArgument(int i),
           List<int> implicitFunctionTypeIndices) =>
       DynamicTypeImpl.instance;
 
   @override
-  ReferenceableElementForLink getContainedName(String name) => this;
+  ReferenceableElementForLink getContainedName(String name) {
+    if (element != null) {
+      DartType type = asStaticType;
+      if (type is InterfaceType) {
+        PropertyAccessorElement getter =
+            type.lookUpGetter(name, element.library);
+        if (getter != null) {
+          return new NonstaticMemberElementForLink(getter, _constNode);
+        }

[Paul Berry, 2016/04/16 14:50:09]

else {
  return new NonStaticMemberElementForLink(null, _constNode);
}

So that we don't allow "trying again" after a failed lookup.  E.g. your code
would allow:

class A {
  B b;
}
class B {
  int c;
}
A a;
var x = a.b.foo.c; // Incorrectly infers type of `int`

[scheglov, 2016/04/17 02:38:26]

Done.

+      }
+    }
+    return this;
+  }
 }
 
 /**
  * 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 952 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) {
-    return new NonstaticMemberElementForLink(_constNode);
+    Element element = _getContainedElement(name);
+    return new NonstaticMemberElementForLink(element, _constNode);
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+
+  /**
+   * Return the contained element with the given [name], or `null` if the lookup
+   * fails.

[Paul Berry, 2016/04/16 14:50:09]

Comment should reflect the fact that we don't do the lookup if we're not in
strong mode (and why)

[scheglov, 2016/04/17 02:38:26]

Done.

+   */
+  Element _getContainedElement(String name) {
+    Linker linker = compilationUnit.library._linker;
+    if (linker.strongMode) {
+      DartType type = asStaticType;
+      if (type is InterfaceType) {
+        return type.lookUpGetter(name, compilationUnit.library);
+      }
+    }
+    return null;
+  }
 }