Issue 25218. The reference type of 'A' in 'A..foo' is 'Type'.

pkg/analyzer/lib/src/generated/element_resolver.dart

 // Copyright (c) 2014, 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 analyzer.src.generated.element_resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 84 matching lines @@
   bool _enableStrictCallChecks = false;
 
   /**
    * The type representing the type 'dynamic'.
    */
   DartType _dynamicType;
 
   /**
    * The type representing the type 'type'.
    */
-  DartType _typeType;
+  InterfaceType _typeType;
 
   /**
    * A utility class for the resolver to answer the question of "what are my
    * subtypes?".
    */
   SubtypeManager _subtypeManager;
 
   /**
    * The object keeping track of which elements have had their types promoted.
    */
@@ skipping 471 matching lines @@
     // We have a method invocation of one of two forms: 'e.m(a1, ..., an)' or
     // 'm(a1, ..., an)'. The first step is to figure out which executable is
     // being invoked, using both the static and the propagated type information.
     //
     Expression target = node.realTarget;
     if (target is SuperExpression && !_isSuperInValidContext(target)) {
       return null;
     }
     Element staticElement;
     Element propagatedElement;
-    DartType staticType = null;
-    DartType propagatedType = null;
     if (target == null) {
       staticElement = _resolveInvokedElement(methodName);
       propagatedElement = null;
     } else if (methodName.name == FunctionElement.LOAD_LIBRARY_NAME &&
         _isDeferredPrefix(target)) {
       if (node.operator.type == sc.TokenType.QUESTION_PERIOD) {
         _resolver.reportErrorForNode(
             CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT,
             target,
             [(target as SimpleIdentifier).name]);
       }
       LibraryElement importedLibrary = _getImportedLibrary(target);
       methodName.staticElement = importedLibrary.loadLibraryFunction;
       return null;
     } else {
-      staticType = _getStaticType(target);
-      propagatedType = _getPropagatedType(target);
       //
       // If this method invocation is of the form 'C.m' where 'C' is a class,
       // then we don't call resolveInvokedElement(...) which walks up the class
       // hierarchy, instead we just look for the member in the type only.  This
       // does not apply to conditional method invocation (i.e. 'C?.m(...)').
       //
       bool isConditional = node.operator.type == sc.TokenType.QUESTION_PERIOD;
       ClassElementImpl typeReference = getTypeReference(target);
       if (typeReference != null) {
+        if (node.isCascaded) {
+          typeReference = _typeType.element;
+        }
         staticElement = _resolveElement(typeReference, methodName);
       } else {
+        DartType staticType = _getStaticType(target);
+        DartType propagatedType = _getPropagatedType(target);
         staticElement = _resolveInvokedElementWithTarget(
             target, staticType, methodName, isConditional);
         // If we have propagated type information use it (since it should
         // not be redundant with the staticType).  Otherwise, don't produce
         // a propagatedElement which duplicates the staticElement.
         if (propagatedType is InterfaceType) {
           propagatedElement = _resolveInvokedElementWithTarget(
               target, propagatedType, methodName, isConditional);
         }
       }
@@ skipping 129 matching lines @@
         }
         if (!_enableStrictCallChecks &&
             targetType != null &&
             targetType.isDartCoreFunction &&
             methodName.name == FunctionElement.CALL_METHOD_NAME) {
           // TODO(brianwilkerson) Can we ever resolve the function being
           // invoked?
 //          resolveArgumentsToParameters(node.getArgumentList(), invokedFunction);
           return null;
         }
-        ClassElementImpl typeReference = getTypeReference(target);
-        if (typeReference != null) {
-          ConstructorElement constructor =
-              typeReference.getNamedConstructor(methodName.name);
-          if (constructor != null) {
-            _recordUndefinedNode(
-                typeReference,
-                StaticTypeWarningCode.UNDEFINED_METHOD_WITH_CONSTRUCTOR,
-                methodName,
-                [methodName.name, typeReference.name]);
-            return null;
+        if (!node.isCascaded) {
+          ClassElementImpl typeReference = getTypeReference(target);
+          if (typeReference != null) {
+            ConstructorElement constructor =
+                typeReference.getNamedConstructor(methodName.name);
+            if (constructor != null) {
+              _recordUndefinedNode(
+                  typeReference,
+                  StaticTypeWarningCode.UNDEFINED_METHOD_WITH_CONSTRUCTOR,
+                  methodName,
+                  [methodName.name, typeReference.name]);
+              return null;
+            }
           }
         }
         targetTypeName = targetType == null ? null : targetType.displayName;
         ErrorCode proxyErrorCode = (generatedWithTypePropagation
             ? HintCode.UNDEFINED_METHOD
             : StaticTypeWarningCode.UNDEFINED_METHOD);
         _recordUndefinedNode(targetType.element, proxyErrorCode, methodName,
             [methodName.name, targetTypeName]);
       }
     } else if (identical(
@@ skipping 119 matching lines @@
     }
     // May be annotation, resolve invocation of "const" constructor.
     if (node.parent is Annotation) {
       Annotation annotation = node.parent as Annotation;
       _resolveAnnotationElement(annotation);
     }
     //
     // Otherwise, the prefix is really an expression that happens to be a simple
     // identifier and this is really equivalent to a property access node.
     //
-    _resolvePropertyAccess(prefix, identifier);
+    _resolvePropertyAccess(prefix, identifier, false);
     return null;
   }
 
   @override
   Object visitPrefixExpression(PrefixExpression node) {
     sc.Token operator = node.operator;
     sc.TokenType operatorType = operator.type;
     if (operatorType.isUserDefinableOperator ||
         operatorType == sc.TokenType.PLUS_PLUS ||
         operatorType == sc.TokenType.MINUS_MINUS) {
@@ skipping 35 matching lines @@
     return null;
   }
 
   @override
   Object visitPropertyAccess(PropertyAccess node) {
     Expression target = node.realTarget;
     if (target is SuperExpression && !_isSuperInValidContext(target)) {
       return null;
     }
     SimpleIdentifier propertyName = node.propertyName;
-    _resolvePropertyAccess(target, propertyName);
+    _resolvePropertyAccess(target, propertyName, node.isCascaded);
     return null;
   }
 
   @override
   Object visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     ClassElement enclosingClass = _resolver.enclosingClass;
     if (enclosingClass == null) {
       // TODO(brianwilkerson) Report this error.
       return null;
@@ skipping 1251 matching lines @@
     if (memberElement == null) {
       memberElement = _lookUpGetter(target, targetType, propertyName.name);
     }
     if (memberElement == null) {
       memberElement = _lookUpMethod(target, targetType, propertyName.name);
     }
     return memberElement;
   }
 
   void _resolvePropertyAccess(
-      Expression target, SimpleIdentifier propertyName) {
+      Expression target, SimpleIdentifier propertyName, bool isCascaded) {
     DartType staticType = _getStaticType(target);
     DartType propagatedType = _getPropagatedType(target);
     Element staticElement = null;
     Element propagatedElement = null;
     //
     // If this property access is of the form 'C.m' where 'C' is a class,
     // then we don't call resolveProperty(...) which walks up the class
     // hierarchy, instead we just look for the member in the type only.  This
     // does not apply to conditional property accesses (i.e. 'C?.m').
     //
     ClassElementImpl typeReference = getTypeReference(target);
     if (typeReference != null) {
+      if (isCascaded) {
+        typeReference = _typeType.element;
+      }
       // TODO(brianwilkerson) Why are we setting the propagated element here?
       // It looks wrong.
       staticElement =
           propagatedElement = _resolveElement(typeReference, propertyName);
     } else {
       staticElement = _resolveProperty(target, staticType, propertyName);
       propagatedElement =
           _resolveProperty(target, propagatedType, propertyName);
     }
     // May be part of annotation, record property element only if exists.
@@ skipping 358 matching lines @@
 
   @override
   Element get staticElement => null;
 
   @override
   accept(AstVisitor visitor) => null;
 
   @override
   void visitChildren(AstVisitor visitor) {}
 }