Implement the new '?.' operator in analyzer.

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 engine.resolver.element_resolver;
 
 import 'dart:collection';
 
 import 'ast.dart';
 import 'element.dart';
@@ skipping 575 matching lines @@
     } else if (methodName.name == FunctionElement.LOAD_LIBRARY_NAME &&
         _isDeferredPrefix(target)) {
       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

[Brian Wilkerson, 2015/04/05 19:55:45]

".." --> "..."

[Paul Berry, 2015/04/05 20:49:43]

Done.

-      // hierarchy, instead we just look for the member in the type only.
+      // hierarchy, instead we just look for the member in the type only.  This
+      // does not apply to conditional method invocation (i.e. 'C?.m(...)').
       //
-      ClassElementImpl typeReference = getTypeReference(target);
+      bool isConditional = node.operator.type == sc.TokenType.QUESTION_PERIOD;
+      ClassElementImpl typeReference = getTypeReference(target, isConditional);
       if (typeReference != null) {
         staticElement =
             propagatedElement = _resolveElement(typeReference, methodName);
       } else {
         staticElement =
             _resolveInvokedElementWithTarget(target, staticType, methodName);
         propagatedElement = _resolveInvokedElementWithTarget(
             target, propagatedType, methodName);
       }
     }
@@ skipping 238 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.operator.type == sc.TokenType.QUESTION_PERIOD);
     return null;
   }
 
   @override
   Object visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     ClassElement enclosingClass = _resolver.enclosingClass;
     if (enclosingClass == null) {
       // TODO(brianwilkerson) Report this error.
       return null;
@@ skipping 1511 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 isConditional) {
     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

[Brian Wilkerson, 2015/04/05 19:55:45]

".." --> "..."

[Paul Berry, 2015/04/05 20:49:43]

Done.

-    // hierarchy, instead we just look for the member in the type only.
+    // 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);
+    ClassElementImpl typeReference = getTypeReference(target, isConditional);
     if (typeReference != null) {
       // 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);
     }
@@ skipping 227 matching lines @@
   bool _shouldReportMissingMember(DartType type, Element member) {
     if (member != null || type == null || type.isDynamic || type.isBottom) {
       return false;
     }
     return true;
   }
 
   /**
    * Checks whether the given [expression] is a reference to a class. If it is
    * then the element representing the class is returned, otherwise `null` is
-   * returned.
+   * returned.  [isConditional] indicates whether [expression] is to the left
+   * of a '?.' opertator.
    */
-  static ClassElementImpl getTypeReference(Expression expression) {
-    if (expression is Identifier) {
+  static ClassElementImpl getTypeReference(
+      Expression expression, bool isConditional) {
+    if (!isConditional && expression is Identifier) {
       Element staticElement = expression.staticElement;
       if (staticElement is ClassElementImpl) {
         return staticElement;
       }
     }
     return null;
   }
 
   /**
    * Helper function for `maybeMergeExecutableElements` that does the actual
@@ skipping 190 matching lines @@
 
   @override
   Element get staticElement => null;
 
   @override
   accept(AstVisitor visitor) => null;
 
   @override
   void visitChildren(AstVisitor visitor) {}
 }