Fix issue 21426

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 766 matching lines @@
     Expression operand = node.operand;
     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)) {
-      _recordUndefinedToken(
-          staticType.element,
-          StaticTypeWarningCode.UNDEFINED_OPERATOR,
-          node.operator,
-          [methodName, staticType.displayName]);
+      if (operand is SuperExpression) {
+        _recordUndefinedToken(
+            staticType.element,
+            StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR,
+            node.operator,
+            [methodName, staticType.displayName]);
+      } else {
+        _recordUndefinedToken(
+            staticType.element,
+            StaticTypeWarningCode.UNDEFINED_OPERATOR,
+            node.operator,
+            [methodName, staticType.displayName]);
+      }
     } else if (_enableHints &&
-        _shouldReportMissingMember(propagatedType, propagatedMethod) &&
-        !_memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
+      _shouldReportMissingMember(propagatedType, propagatedMethod) &&
+      !_memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
       _recordUndefinedToken(
           propagatedType.element,
           HintCode.UNDEFINED_OPERATOR,
           node.operator,
           [methodName, propagatedType.displayName]);
     }
     return null;
   }
 
   @override
@@ skipping 85 matching lines @@
       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)) {
-        _recordUndefinedToken(
-            staticType.element,
-            StaticTypeWarningCode.UNDEFINED_OPERATOR,
-            operator,
-            [methodName, staticType.displayName]);
+        if (operand is SuperExpression) {
+          _recordUndefinedToken(
+              staticType.element,
+              StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR,
+              operator,
+              [methodName, staticType.displayName]);
+        } else {
+          _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]);
       }
     }
@@ skipping 333 matching lines @@
         _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 = node.leftBracket;
       sc.Token rightBracket = node.rightBracket;
-      ErrorCode errorCode = (shouldReportMissingMember_static ?
-          StaticTypeWarningCode.UNDEFINED_OPERATOR :
-          HintCode.UNDEFINED_OPERATOR);
+      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(
-            shouldReportMissingMember_static ? staticType.element : propagatedType.element,
+            type.element,
             errorCode,
             node,
-            [
-                methodName,
-                shouldReportMissingMember_static ?
-                    staticType.displayName :
-                    propagatedType.displayName]);
+            [methodName, type.displayName]);
       } else {
         int offset = leftBracket.offset;
         int length = rightBracket.offset - offset + 1;
         _recordUndefinedOffset(
-            shouldReportMissingMember_static ? staticType.element : propagatedType.element,
+            type.element,
             errorCode,
             offset,
             length,
-            [
-                methodName,
-                shouldReportMissingMember_static ?
-                    staticType.displayName :
-                    propagatedType.displayName]);
+            [methodName, type.displayName]);
       }
       return true;
     }
     return false;
   }
 
   /**
    * Given a list of arguments and the element that will be invoked using those argument, compute
    * the list of parameters that correspond to the list of arguments. Return the parameters that
    * correspond to the arguments, or `null` if no correspondence could be computed.
@@ skipping 1107 matching lines @@
     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)) {
-        _recordUndefinedToken(
-            staticType.element,
-            StaticTypeWarningCode.UNDEFINED_OPERATOR,
-            node.operator,
-            [methodName, staticType.displayName]);
+        if (leftOperand is SuperExpression) {
+          _recordUndefinedToken(
+              staticType.element,
+              StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR,
+              node.operator,
+              [methodName, staticType.displayName]);
+        } else {
+          _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]);
       }
     }
@@ skipping 213 matching lines @@
         _shouldReportMissingMember(propagatedType, propagatedElement) &&
         !_memberFoundInSubclass(propagatedType.element, propertyName.name, false, true);
     // TODO(collinsn): add support for errors on union types by extending
     // [lookupGetter] and [lookupSetter] in analogy with the earlier
     // [lookupMethod] extensions.
     if (propagatedType is UnionType) {
       shouldReportMissingMember_propagated = false;
     }
     if (shouldReportMissingMember_static ||
         shouldReportMissingMember_propagated) {
-      Element staticOrPropagatedEnclosingElt =
-          shouldReportMissingMember_static ? staticType.element : propagatedType.element;
+      DartType staticOrPropagatedType =
+          shouldReportMissingMember_static ? staticType : propagatedType;
+      Element staticOrPropagatedEnclosingElt = staticOrPropagatedType.element;
       bool isStaticProperty = _isStatic(staticOrPropagatedEnclosingElt);
-      String displayName = staticOrPropagatedEnclosingElt != null ?
-          staticOrPropagatedEnclosingElt.displayName :
-          propagatedType != null ? propagatedType.displayName : staticType.displayName;
+      DartType displayType = staticOrPropagatedType != null ?
+          staticOrPropagatedType :
+          propagatedType != null ? propagatedType : staticType;
       // Special getter cases.
       if (propertyName.inGetterContext()) {
         if (!isStaticProperty &&
             staticOrPropagatedEnclosingElt is ClassElement) {
           ClassElement classElement = staticOrPropagatedEnclosingElt;
           InterfaceType targetType = classElement.type;
           if (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,
                 [propertyName.name]);
             return;
           }
         }
       }
       Element declaringElement =
           staticType.isVoid ? null : staticOrPropagatedEnclosingElt;
       if (propertyName.inSetterContext()) {
-        ErrorCode staticErrorCode = (isStaticProperty && !staticType.isVoid ?
-            StaticWarningCode.UNDEFINED_SETTER :
-            StaticTypeWarningCode.UNDEFINED_SETTER);
-        ErrorCode errorCode =
-            shouldReportMissingMember_static ? staticErrorCode : HintCode.UNDEFINED_SETTER;
+        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, displayName]);
+            [propertyName.name, displayType.displayName]);
       } else if (propertyName.inGetterContext()) {
-        ErrorCode staticErrorCode = (isStaticProperty && !staticType.isVoid ?
-            StaticWarningCode.UNDEFINED_GETTER :
-            StaticTypeWarningCode.UNDEFINED_GETTER);
-        ErrorCode errorCode =
-            shouldReportMissingMember_static ? staticErrorCode : HintCode.UNDEFINED_GETTER;
+        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, displayName]);
+            [propertyName.name, displayType.displayName]);
       } else {
         _recordUndefinedNode(
             declaringElement,
             StaticWarningCode.UNDEFINED_IDENTIFIER,
             propertyName,
             [propertyName.name]);
       }
     }
   }
 
@@ skipping 352 matching lines @@
   @override
   Element get staticElement => null;
 
   @override
   accept(AstVisitor visitor) => null;
 
   @override
   void visitChildren(AstVisitor visitor) {
   }
 }