Roll Observatory packages and add a roll script

packages/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 143 matching lines @@
         String methodName = operatorType.lexeme;
         DartType staticType = _getStaticType(leftHandSide);
         MethodElement staticMethod =
             _lookUpMethod(leftHandSide, staticType, methodName);
         node.staticElement = staticMethod;
         DartType propagatedType = _getPropagatedType(leftHandSide);
         MethodElement propagatedMethod =
             _lookUpMethod(leftHandSide, propagatedType, methodName);
         node.propagatedElement = propagatedMethod;
         if (_shouldReportMissingMember(staticType, staticMethod)) {
-          _recordUndefinedToken(staticType.element,
-              StaticTypeWarningCode.UNDEFINED_METHOD, operator, [
-            methodName,
-            staticType.displayName
-          ]);
+          _recordUndefinedToken(
+              staticType.element,
+              StaticTypeWarningCode.UNDEFINED_METHOD,
+              operator,
+              [methodName, staticType.displayName]);
         } else if (_enableHints &&
             _shouldReportMissingMember(propagatedType, propagatedMethod) &&
             !_memberFoundInSubclass(
                 propagatedType.element, methodName, true, false)) {
-          _recordUndefinedToken(propagatedType.element,
-              HintCode.UNDEFINED_METHOD, operator, [
-            methodName,
-            propagatedType.displayName
-          ]);
+          _recordUndefinedToken(
+              propagatedType.element,
+              HintCode.UNDEFINED_METHOD,
+              operator,
+              [methodName, propagatedType.displayName]);
         }
       }
     }
     return null;
   }
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
     sc.Token operator = node.operator;
     if (operator.isUserDefinableOperator) {
       _resolveBinaryExpression(node, operator.lexeme);
     } else if (operator.type == sc.TokenType.BANG_EQ) {
       _resolveBinaryExpression(node, sc.TokenType.EQ_EQ.lexeme);
     }
     return null;
   }
 
   @override
   Object visitBreakStatement(BreakStatement node) {
     node.target = _lookupBreakOrContinueTarget(node, node.label, false);
     return null;
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
     setMetadata(node.element, node);
     return null;
   }
+
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     setMetadata(node.element, node);
     return null;
   }
 
   @override
   Object visitCommentReference(CommentReference node) {
     Identifier identifier = node.identifier;
     if (identifier is SimpleIdentifier) {
@@ skipping 271 matching lines @@
     if (isInGetterContext && isInSetterContext) {
       // lookup setter
       MethodElement setterStaticMethod =
           _lookUpMethod(target, staticType, setterMethodName);
       MethodElement setterPropagatedMethod =
           _lookUpMethod(target, propagatedType, setterMethodName);
       // set setter element
       node.staticElement = setterStaticMethod;
       node.propagatedElement = setterPropagatedMethod;
       // generate undefined method warning
-      _checkForUndefinedIndexOperator(node, target, getterMethodName,
-          setterStaticMethod, setterPropagatedMethod, staticType,
+      _checkForUndefinedIndexOperator(
+          node,
+          target,
+          getterMethodName,
+          setterStaticMethod,
+          setterPropagatedMethod,
+          staticType,
           propagatedType);
       // lookup getter method
       MethodElement getterStaticMethod =
           _lookUpMethod(target, staticType, getterMethodName);
       MethodElement getterPropagatedMethod =
           _lookUpMethod(target, propagatedType, getterMethodName);
       // set getter element
       AuxiliaryElements auxiliaryElements =
           new AuxiliaryElements(getterStaticMethod, getterPropagatedMethod);
       node.auxiliaryElements = auxiliaryElements;
       // generate undefined method warning
-      _checkForUndefinedIndexOperator(node, target, getterMethodName,
-          getterStaticMethod, getterPropagatedMethod, staticType,
+      _checkForUndefinedIndexOperator(
+          node,
+          target,
+          getterMethodName,
+          getterStaticMethod,
+          getterPropagatedMethod,
+          staticType,
           propagatedType);
     } else if (isInGetterContext) {
       // lookup getter method
       MethodElement staticMethod =
           _lookUpMethod(target, staticType, getterMethodName);
       MethodElement propagatedMethod =
           _lookUpMethod(target, propagatedType, getterMethodName);
       // set getter element
       node.staticElement = staticMethod;
       node.propagatedElement = propagatedMethod;
@@ skipping 63 matching lines @@
     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,
+            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, isConditional);
+      ClassElementImpl typeReference = getTypeReference(target);
       if (typeReference != null) {
         staticElement =
             propagatedElement = _resolveElement(typeReference, methodName);
       } else {
         staticElement = _resolveInvokedElementWithTarget(
             target, staticType, methodName, isConditional);
         propagatedElement = _resolveInvokedElementWithTarget(
             target, propagatedType, methodName, isConditional);
       }
     }
@@ skipping 92 matching lines @@
             methodName.name == FunctionElement.CALL_METHOD_NAME) {
           // TODO(brianwilkerson) Can we ever resolve the function being
           // invoked?
 //          resolveArgumentsToParameters(node.getArgumentList(), invokedFunction);
           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
-        ]);
+        _recordUndefinedNode(targetType.element, proxyErrorCode, methodName,
+            [methodName.name, targetTypeName]);
       }
     } else if (identical(
         errorCode, StaticTypeWarningCode.UNDEFINED_SUPER_METHOD)) {
       // Generate the type name.
       // The error code will never be generated via type propagation
       DartType targetType = _getStaticType(target);
       if (targetType is InterfaceType && !targetType.isObject) {
         targetType = (targetType as InterfaceType).superclass;
       }
       String targetTypeName = targetType == null ? null : targetType.name;
@@ skipping 21 matching lines @@
     String methodName = _getPostfixOperator(node);
     DartType staticType = _getStaticType(operand);
     MethodElement staticMethod = _lookUpMethod(operand, staticType, methodName);
     node.staticElement = staticMethod;
     DartType propagatedType = _getPropagatedType(operand);
     MethodElement propagatedMethod =
         _lookUpMethod(operand, propagatedType, methodName);
     node.propagatedElement = propagatedMethod;
     if (_shouldReportMissingMember(staticType, staticMethod)) {
       if (operand is SuperExpression) {
-        _recordUndefinedToken(staticType.element,
-            StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR, node.operator, [
-          methodName,
-          staticType.displayName
-        ]);
+        _recordUndefinedToken(
+            staticType.element,
+            StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR,
+            node.operator,
+            [methodName, staticType.displayName]);
       } else {
-        _recordUndefinedToken(staticType.element,
-            StaticTypeWarningCode.UNDEFINED_OPERATOR, node.operator, [
-          methodName,
-          staticType.displayName
-        ]);
+        _recordUndefinedToken(
+            staticType.element,
+            StaticTypeWarningCode.UNDEFINED_OPERATOR,
+            node.operator,
+            [methodName, staticType.displayName]);
       }
     } else if (_enableHints &&
         _shouldReportMissingMember(propagatedType, propagatedMethod) &&
         !_memberFoundInSubclass(
             propagatedType.element, methodName, true, false)) {
       _recordUndefinedToken(propagatedType.element, HintCode.UNDEFINED_OPERATOR,
           node.operator, [methodName, propagatedType.displayName]);
     }
     return null;
   }
@@ skipping 59 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, false);
+    _resolvePropertyAccess(prefix, identifier);
     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) {
       Expression operand = node.operand;
       String methodName = _getPrefixOperator(node);
       DartType staticType = _getStaticType(operand);
       MethodElement staticMethod =
           _lookUpMethod(operand, staticType, methodName);
       node.staticElement = staticMethod;
       DartType propagatedType = _getPropagatedType(operand);
       MethodElement propagatedMethod =
           _lookUpMethod(operand, propagatedType, methodName);
       node.propagatedElement = propagatedMethod;
       if (_shouldReportMissingMember(staticType, staticMethod)) {
         if (operand is SuperExpression) {
-          _recordUndefinedToken(staticType.element,
-              StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR, operator, [
-            methodName,
-            staticType.displayName
-          ]);
+          _recordUndefinedToken(
+              staticType.element,
+              StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR,
+              operator,
+              [methodName, staticType.displayName]);
         } else {
-          _recordUndefinedToken(staticType.element,
-              StaticTypeWarningCode.UNDEFINED_OPERATOR, operator, [
-            methodName,
-            staticType.displayName
-          ]);
+          _recordUndefinedToken(
+              staticType.element,
+              StaticTypeWarningCode.UNDEFINED_OPERATOR,
+              operator,
+              [methodName, staticType.displayName]);
         }
       } else if (_enableHints &&
           _shouldReportMissingMember(propagatedType, propagatedMethod) &&
           !_memberFoundInSubclass(
               propagatedType.element, methodName, true, false)) {
-        _recordUndefinedToken(propagatedType.element,
-            HintCode.UNDEFINED_OPERATOR, operator, [
-          methodName,
-          propagatedType.displayName
-        ]);
+        _recordUndefinedToken(
+            propagatedType.element,
+            HintCode.UNDEFINED_OPERATOR,
+            operator,
+            [methodName, propagatedType.displayName]);
       }
     }
     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,
-        node.operator.type == sc.TokenType.QUESTION_PERIOD);
+    _resolvePropertyAccess(target, propertyName);
     return null;
   }
 
   @override
   Object visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     ClassElement enclosingClass = _resolver.enclosingClass;
     if (enclosingClass == null) {
       // TODO(brianwilkerson) Report this error.
       return null;
@@ skipping 72 matching lines @@
       // TODO(brianwilkerson) Recover from this error.
       if (_isConstructorReturnType(node)) {
         _resolver.reportErrorForNode(
             CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME, node);
       } else if (node.parent is Annotation) {
         Annotation annotation = node.parent as Annotation;
         _resolver.reportErrorForNode(
             CompileTimeErrorCode.INVALID_ANNOTATION, annotation);
       } else if (element is PrefixElement) {
         _resolver.reportErrorForNode(
-            CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT, node,
+            CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT,
+            node,
             [element.name]);
       } else {
         _recordUndefinedNode(_resolver.enclosingClass,
             StaticWarningCode.UNDEFINED_IDENTIFIER, node, [node.name]);
       }
     }
     node.staticElement = element;
     if (node.inSetterContext() &&
         node.inGetterContext() &&
         enclosingClass != null) {
@@ skipping 26 matching lines @@
     }
     SimpleIdentifier name = node.constructorName;
     String superName = name != null ? name.name : null;
     ConstructorElement element =
         superType.lookUpConstructor(superName, _definingLibrary);
     if (element == null ||
         (!enclosingClass.doesMixinLackConstructors &&
             !enclosingClass.isSuperConstructorAccessible(element))) {
       if (name != null) {
         _resolver.reportErrorForNode(
-            CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER, node, [
-          superType.displayName,
-          name
-        ]);
+            CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER,
+            node,
+            [superType.displayName, name]);
       } else {
         _resolver.reportErrorForNode(
             CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT,
-            node, [superType.displayName]);
+            node,
+            [superType.displayName]);
       }
       return null;
     } else {
       if (element.isFactory) {
         _resolver.reportErrorForNode(
             CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node, [element]);
       }
     }
     if (name != null) {
       name.staticElement = element;
@@ skipping 117 matching lines @@
     }
     return null;
   }
 
   /**
    * Check that the given index [expression] was resolved, otherwise a
    * [StaticTypeWarningCode.UNDEFINED_OPERATOR] is generated. The [target] is
    * the target of the expression. The [methodName] is the name of the operator
    * associated with the context of using of the given index expression.
    */
-  bool _checkForUndefinedIndexOperator(IndexExpression expression,
-      Expression target, String methodName, MethodElement staticMethod,
-      MethodElement propagatedMethod, DartType staticType,
+  bool _checkForUndefinedIndexOperator(
+      IndexExpression expression,
+      Expression target,
+      String methodName,
+      MethodElement staticMethod,
+      MethodElement propagatedMethod,
+      DartType staticType,
       DartType propagatedType) {
     bool shouldReportMissingMember_static =
         _shouldReportMissingMember(staticType, staticMethod);
     bool shouldReportMissingMember_propagated =
         !shouldReportMissingMember_static &&
             _enableHints &&
             _shouldReportMissingMember(propagatedType, propagatedMethod) &&
             !_memberFoundInSubclass(
                 propagatedType.element, methodName, true, false);
     if (shouldReportMissingMember_static ||
         shouldReportMissingMember_propagated) {
       sc.Token leftBracket = expression.leftBracket;
       sc.Token rightBracket = expression.rightBracket;
       ErrorCode errorCode;
       if (shouldReportMissingMember_static) {
         if (target is SuperExpression) {
           errorCode = StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR;
         } else {
           errorCode = StaticTypeWarningCode.UNDEFINED_OPERATOR;
         }
       } else {
         errorCode = HintCode.UNDEFINED_OPERATOR;
       }
       DartType type =
           shouldReportMissingMember_static ? staticType : propagatedType;
       if (leftBracket == null || rightBracket == null) {
-        _recordUndefinedNode(type.element, errorCode, expression, [
-          methodName,
-          type.displayName
-        ]);
+        _recordUndefinedNode(type.element, errorCode, expression,
+            [methodName, type.displayName]);
       } else {
         int offset = leftBracket.offset;
         int length = rightBracket.offset - offset + 1;
-        _recordUndefinedOffset(type.element, errorCode, offset, length, [
-          methodName,
-          type.displayName
-        ]);
+        _recordUndefinedOffset(type.element, errorCode, offset, length,
+            [methodName, type.displayName]);
       }
       return true;
     }
     return false;
   }
 
   /**
    * Given an [argumentList] and the executable [element] that  will be invoked
    * using those arguments, compute the list of parameters that correspond to
    * the list of arguments. Return the parameters that correspond to the
@@ skipping 324 matching lines @@
   /**
    * Look up the getter with the given [getterName] in the interfaces
    * implemented by the given [targetType], either directly or indirectly.
    * Return the element representing the getter that was found, or `null` if
    * there is no getter with the given name. The flag [includeTargetType] should
    * be `true` if the search should include the target type. The
    * [visitedInterfaces] is a set containing all of the interfaces that have
    * been examined, used to prevent infinite recursion and to optimize the
    * search.
    */
-  PropertyAccessorElement _lookUpGetterInInterfaces(InterfaceType targetType,
-      bool includeTargetType, String getterName,
+  PropertyAccessorElement _lookUpGetterInInterfaces(
+      InterfaceType targetType,
+      bool includeTargetType,
+      String getterName,
       HashSet<ClassElement> visitedInterfaces) {
     // TODO(brianwilkerson) This isn't correct. Section 8.1.1 of the
     // specification (titled "Inheritance and Overriding" under "Interfaces")
     // describes a much more complex scheme for finding the inherited member.
     // We need to follow that scheme. The code below should cover the 80% case.
     ClassElement targetClass = targetType.element;
     if (visitedInterfaces.contains(targetClass)) {
       return null;
     }
     visitedInterfaces.add(targetClass);
@@ skipping 52 matching lines @@
   /**
    * Look up the method or getter with the given [memberName] in the interfaces
    * implemented by the given [targetType], either directly or indirectly.
    * Return the element representing the method or getter that was found, or
    * `null` if there is no method or getter with the given name. The flag
    * [includeTargetType] should be `true` if the search should include the
    * target type. The [visitedInterfaces] is a set containing all of the
    * interfaces that have been examined, used to prevent infinite recursion and
    * to optimize the search.
    */
-  ExecutableElement _lookUpGetterOrMethodInInterfaces(InterfaceType targetType,
-      bool includeTargetType, String memberName,
+  ExecutableElement _lookUpGetterOrMethodInInterfaces(
+      InterfaceType targetType,
+      bool includeTargetType,
+      String memberName,
       HashSet<ClassElement> visitedInterfaces) {
     // TODO(brianwilkerson) This isn't correct. Section 8.1.1 of the
     // specification (titled "Inheritance and Overriding" under "Interfaces")
     // describes a much more complex scheme for finding the inherited member.
     // We need to follow that scheme. The code below should cover the 80% case.
     ClassElement targetClass = targetType.element;
     if (visitedInterfaces.contains(targetClass)) {
       return null;
     }
     visitedInterfaces.add(targetClass);
@@ skipping 59 matching lines @@
   /**
    * Look up the method with the given [methodName] in the interfaces
    * implemented by the given [targetType], either directly or indirectly.
    * Return the element representing the method that was found, or `null` if
    * there is no method with the given name. The flag [includeTargetType] should
    * be `true` if the search should include the target type. The
    * [visitedInterfaces] is a set containing all of the interfaces that have
    * been examined, used to prevent infinite recursion and to optimize the
    * search.
    */
-  MethodElement _lookUpMethodInInterfaces(InterfaceType targetType,
-      bool includeTargetType, String methodName,
+  MethodElement _lookUpMethodInInterfaces(
+      InterfaceType targetType,
+      bool includeTargetType,
+      String methodName,
       HashSet<ClassElement> visitedInterfaces) {
     // TODO(brianwilkerson) This isn't correct. Section 8.1.1 of the
     // specification (titled "Inheritance and Overriding" under "Interfaces")
     // describes a much more complex scheme for finding the inherited member.
     // We need to follow that scheme. The code below should cover the 80% case.
     ClassElement targetClass = targetType.element;
     if (visitedInterfaces.contains(targetClass)) {
       return null;
     }
     visitedInterfaces.add(targetClass);
@@ skipping 56 matching lines @@
    * Look up the setter with the given [setterName] in the interfaces
    * implemented by the given [targetType], either directly or indirectly.
    * Return the element representing the setter that was found, or `null` if
    * there is no setter with the given name. The [targetType] is the type in
    * which the setter might be defined. The flag [includeTargetType] should be
    * `true` if the search should include the target type. The
    * [visitedInterfaces] is a set containing all of the interfaces that have
    * been examined, used to prevent infinite recursion and to optimize the
    * search.
    */
-  PropertyAccessorElement _lookUpSetterInInterfaces(InterfaceType targetType,
-      bool includeTargetType, String setterName,
+  PropertyAccessorElement _lookUpSetterInInterfaces(
+      InterfaceType targetType,
+      bool includeTargetType,
+      String setterName,
       HashSet<ClassElement> visitedInterfaces) {
     // TODO(brianwilkerson) This isn't correct. Section 8.1.1 of the
     // specification (titled "Inheritance and Overriding" under "Interfaces")
     // describes a much more complex scheme for finding the inherited member.
     // We need to follow that scheme. The code below should cover the 80% case.
     ClassElement targetClass = targetType.element;
     if (visitedInterfaces.contains(targetClass)) {
       return null;
     }
     visitedInterfaces.add(targetClass);
@@ skipping 175 matching lines @@
     if (nameNode1 != null && nameNode2 == null && nameNode3 == null) {
       Element element1 = nameNode1.staticElement;
       // CONST
       if (element1 is PropertyAccessorElement) {
         _resolveAnnotationElementGetter(annotation, element1);
         return;
       }
       // Class(args)
       if (element1 is ClassElement) {
         ClassElement classElement = element1;
-        constructor = new InterfaceTypeImpl(classElement).lookUpConstructor(
-            null, _definingLibrary);
+        constructor = new InterfaceTypeImpl(classElement)
+            .lookUpConstructor(null, _definingLibrary);
       }
     }
     //
     // prefix.CONST or prefix.Class() or Class.CONST or Class.constructor(args)
     //
     if (nameNode1 != null && nameNode2 != null && nameNode3 == null) {
       Element element1 = nameNode1.staticElement;
       Element element2 = nameNode2.staticElement;
       // Class.CONST - not resolved yet
       if (element1 is ClassElement) {
         ClassElement classElement = element1;
         element2 = classElement.lookUpGetter(nameNode2.name, _definingLibrary);
       }
       // prefix.CONST or Class.CONST
       if (element2 is PropertyAccessorElement) {
         nameNode2.staticElement = element2;
         annotation.element = element2;
         _resolveAnnotationElementGetter(annotation, element2);
         return;
       }
       // prefix.Class()
       if (element2 is ClassElement) {
         constructor = element2.unnamedConstructor;
       }
       // Class.constructor(args)
       if (element1 is ClassElement) {
         ClassElement classElement = element1;
-        constructor = new InterfaceTypeImpl(classElement).lookUpConstructor(
-            nameNode2.name, _definingLibrary);
+        constructor = new InterfaceTypeImpl(classElement)
+            .lookUpConstructor(nameNode2.name, _definingLibrary);
         nameNode2.staticElement = constructor;
       }
     }
     //
     // prefix.Class.CONST or prefix.Class.constructor(args)
     //
     if (nameNode1 != null && nameNode2 != null && nameNode3 != null) {
       Element element2 = nameNode2.staticElement;
       // element2 should be ClassElement
       if (element2 is ClassElement) {
         ClassElement classElement = element2;
         String name3 = nameNode3.name;
         // prefix.Class.CONST
         PropertyAccessorElement getter =
             classElement.lookUpGetter(name3, _definingLibrary);
         if (getter != null) {
           nameNode3.staticElement = getter;
           annotation.element = element2;
           _resolveAnnotationElementGetter(annotation, getter);
           return;
         }
         // prefix.Class.constructor(args)
-        constructor = new InterfaceTypeImpl(classElement).lookUpConstructor(
-            name3, _definingLibrary);
+        constructor = new InterfaceTypeImpl(classElement)
+            .lookUpConstructor(name3, _definingLibrary);
         nameNode3.staticElement = constructor;
       }
     }
     // we need constructor
     if (constructor == null) {
       _resolver.reportErrorForNode(
           CompileTimeErrorCode.INVALID_ANNOTATION, annotation);
       return;
     }
     // record element
@@ skipping 102 matching lines @@
         if (unnamedIndex < unnamedParameterCount) {
           resolvedParameters[i] = unnamedParameters[unnamedIndex++];
         }
       }
     }
     if (positionalArgumentCount < requiredParameters.length &&
         noBlankArguments) {
       ErrorCode errorCode = (reportError
           ? CompileTimeErrorCode.NOT_ENOUGH_REQUIRED_ARGUMENTS
           : StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS);
-      _resolver.reportErrorForNode(errorCode, argumentList, [
-        requiredParameters.length,
-        positionalArgumentCount
-      ]);
+      _resolver.reportErrorForNode(errorCode, argumentList,
+          [requiredParameters.length, positionalArgumentCount]);
     } else if (positionalArgumentCount > unnamedParameterCount &&
         noBlankArguments) {
       ErrorCode errorCode = (reportError
           ? CompileTimeErrorCode.EXTRA_POSITIONAL_ARGUMENTS
           : StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS);
-      _resolver.reportErrorForNode(errorCode, argumentList, [
-        unnamedParameterCount,
-        positionalArgumentCount
-      ]);
+      _resolver.reportErrorForNode(errorCode, argumentList,
+          [unnamedParameterCount, positionalArgumentCount]);
     }
     return resolvedParameters;
   }
 
   void _resolveBinaryExpression(BinaryExpression node, String methodName) {
     Expression leftOperand = node.leftOperand;
     if (leftOperand != null) {
       DartType staticType = _getStaticType(leftOperand);
       MethodElement staticMethod =
           _lookUpMethod(leftOperand, staticType, methodName);
       node.staticElement = staticMethod;
       DartType propagatedType = _getPropagatedType(leftOperand);
       MethodElement propagatedMethod =
           _lookUpMethod(leftOperand, propagatedType, methodName);
       node.propagatedElement = propagatedMethod;
       if (_shouldReportMissingMember(staticType, staticMethod)) {
         if (leftOperand is SuperExpression) {
-          _recordUndefinedToken(staticType.element,
-              StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR, node.operator, [
-            methodName,
-            staticType.displayName
-          ]);
+          _recordUndefinedToken(
+              staticType.element,
+              StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR,
+              node.operator,
+              [methodName, staticType.displayName]);
         } else {
-          _recordUndefinedToken(staticType.element,
-              StaticTypeWarningCode.UNDEFINED_OPERATOR, node.operator, [
-            methodName,
-            staticType.displayName
-          ]);
+          _recordUndefinedToken(
+              staticType.element,
+              StaticTypeWarningCode.UNDEFINED_OPERATOR,
+              node.operator,
+              [methodName, staticType.displayName]);
         }
       } else if (_enableHints &&
           _shouldReportMissingMember(propagatedType, propagatedMethod) &&
           !_memberFoundInSubclass(
               propagatedType.element, methodName, true, false)) {
-        _recordUndefinedToken(propagatedType.element,
-            HintCode.UNDEFINED_OPERATOR, node.operator, [
-          methodName,
-          propagatedType.displayName
-        ]);
+        _recordUndefinedToken(
+            propagatedType.element,
+            HintCode.UNDEFINED_OPERATOR,
+            node.operator,
+            [methodName, propagatedType.displayName]);
       }
     }
   }
 
   /**
    * Resolve the names in the given [combinators] in the scope of the given
    * [library].
    */
   void _resolveCombinators(
       LibraryElement library, NodeList<Combinator> combinators) {
@@ skipping 112 matching lines @@
         // style of [lookUpMethod].
         element = _lookUpGetter(target, targetType, methodName.name);
       }
       return element;
     } else if (target is SimpleIdentifier) {
       Element targetElement = target.staticElement;
       if (targetElement is PrefixElement) {
         if (isConditional) {
           _resolver.reportErrorForNode(
               CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT,
-              target, [target.name]);
+              target,
+              [target.name]);
         }
         //
         // Look to see whether the name of the method is really part of a
         // prefixed identifier for an imported top-level function or top-level
         // getter that returns a function.
         //
         String name = "${target.name}.$methodName";
         Identifier functionName = new SyntheticIdentifier(name, methodName);
         Element element =
             _resolver.nameScope.lookup(functionName, _definingLibrary);
@@ skipping 23 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, bool isConditional) {
+      Expression target, SimpleIdentifier propertyName) {
     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, isConditional);
+    ClassElementImpl typeReference = getTypeReference(target);
     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 33 matching lines @@
           if (!_enableStrictCallChecks &&
               targetType != null &&
               targetType.isDartCoreFunction &&
               propertyName.name == FunctionElement.CALL_METHOD_NAME) {
             // TODO(brianwilkerson) Can we ever resolve the function being
             // invoked?
 //            resolveArgumentsToParameters(node.getArgumentList(), invokedFunction);
             return;
           } else if (classElement.isEnum && propertyName.name == "_name") {
             _resolver.reportErrorForNode(
-                CompileTimeErrorCode.ACCESS_PRIVATE_ENUM_FIELD, propertyName,
+                CompileTimeErrorCode.ACCESS_PRIVATE_ENUM_FIELD,
+                propertyName,
                 [propertyName.name]);
             return;
           }
         }
       }
       Element declaringElement =
           staticType.isVoid ? null : staticOrPropagatedEnclosingElt;
       if (propertyName.inSetterContext()) {
         ErrorCode errorCode;
         if (shouldReportMissingMember_static) {
           if (target is SuperExpression) {
             if (isStaticProperty && !staticType.isVoid) {
               errorCode = StaticWarningCode.UNDEFINED_SUPER_SETTER;
             } else {
               errorCode = StaticTypeWarningCode.UNDEFINED_SUPER_SETTER;
             }
           } else {
             if (isStaticProperty && !staticType.isVoid) {
               errorCode = StaticWarningCode.UNDEFINED_SETTER;
             } else {
               errorCode = StaticTypeWarningCode.UNDEFINED_SETTER;
             }
           }
         } else {
           errorCode = HintCode.UNDEFINED_SETTER;
         }
-        _recordUndefinedNode(declaringElement, errorCode, propertyName, [
-          propertyName.name,
-          displayType.displayName
-        ]);
+        _recordUndefinedNode(declaringElement, errorCode, propertyName,
+            [propertyName.name, displayType.displayName]);
       } else if (propertyName.inGetterContext()) {
         ErrorCode errorCode;
         if (shouldReportMissingMember_static) {
           if (target is SuperExpression) {
             if (isStaticProperty && !staticType.isVoid) {
               errorCode = StaticWarningCode.UNDEFINED_SUPER_GETTER;
             } else {
               errorCode = StaticTypeWarningCode.UNDEFINED_SUPER_GETTER;
             }
           } else {
             if (isStaticProperty && !staticType.isVoid) {
               errorCode = StaticWarningCode.UNDEFINED_GETTER;
             } else {
               errorCode = StaticTypeWarningCode.UNDEFINED_GETTER;
             }
           }
         } else {
           errorCode = HintCode.UNDEFINED_GETTER;
         }
-        _recordUndefinedNode(declaringElement, errorCode, propertyName, [
-          propertyName.name,
-          displayType.displayName
-        ]);
+        _recordUndefinedNode(declaringElement, errorCode, propertyName,
+            [propertyName.name, displayType.displayName]);
       } else {
-        _recordUndefinedNode(declaringElement,
-            StaticWarningCode.UNDEFINED_IDENTIFIER, propertyName,
+        _recordUndefinedNode(
+            declaringElement,
+            StaticWarningCode.UNDEFINED_IDENTIFIER,
+            propertyName,
             [propertyName.name]);
       }
     }
   }
 
   /**
    * Resolve the given simple [identifier] if possible. Return the element to
    * which it could be resolved, or `null` if it could not be resolved. This
    * does not record the results of the resolution.
    */
@@ skipping 82 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.  [isConditional] indicates whether [expression] is to the left
-   * of a '?.' opertator.
+   * returned.
    */
-  static ClassElementImpl getTypeReference(
-      Expression expression, bool isConditional) {
-    if (!isConditional && expression is Identifier) {
+  static ClassElementImpl getTypeReference(Expression expression) {
+    if (expression is Identifier) {
       Element staticElement = expression.staticElement;
       if (staticElement is ClassElementImpl) {
         return staticElement;
       }
     }
     return null;
   }
 
   /**
    * Given a [node] that can have annotations associated with it and the
@@ skipping 144 matching lines @@
 
   @override
   Element get staticElement => null;
 
   @override
   accept(AstVisitor visitor) => null;
 
   @override
   void visitChildren(AstVisitor visitor) {}
 }