ignore `@proxy` in strong mode

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/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/syntactic_entity.dart';
@@ skipping 741 matching lines @@
               errorCode = null;
             }
           }
         }
       }
       generatedWithTypePropagation = true;
     }
     if (errorCode == null) {
       return null;
     }
+
     if (identical(
             errorCode, StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION) ||
         identical(errorCode,
             CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT) ||
         identical(errorCode, StaticTypeWarningCode.UNDEFINED_FUNCTION)) {
       if (!_resolver.nameScope.shouldIgnoreUndefined(methodName)) {
         _resolver.errorReporter
             .reportErrorForNode(errorCode, methodName, [methodName.name]);
       }
     } else if (identical(errorCode, StaticTypeWarningCode.UNDEFINED_METHOD)) {
@@ skipping 37 matching lines @@
             if (constructor != null) {
               _recordUndefinedNode(
                   typeReference,
                   StaticTypeWarningCode.UNDEFINED_METHOD_WITH_CONSTRUCTOR,
                   methodName,
                   [methodName.name, typeReference.name]);
               return null;
             }
           }
         }
+
         targetTypeName = targetType?.displayName;
         ErrorCode proxyErrorCode = (generatedWithTypePropagation
             ? HintCode.UNDEFINED_METHOD
             : StaticTypeWarningCode.UNDEFINED_METHOD);
+
         _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 getSuperType(DartType type) {
         if (type is InterfaceType && !type.isObject) {
           return type.superclass;
@@ skipping 575 matching lines @@
   Element _convertSetterToGetter(Element element) {
     // TODO(brianwilkerson) Determine whether and why the element could ever be
     // a setter.
     if (element is PropertyAccessorElement) {
       return element.variable.getter;
     }
     return element;
   }
 
   /**
-   * Return `true` if the given [element] is not a proxy. See
-   * [ClassElement.isOrInheritsProxy].
+   * Return `true` if the given [element] is or inherits from a class marked
+   * with `@proxy`.
+   * 
+   * See [ClassElement.isOrInheritsProxy].
    */
-  bool _doesntHaveProxy(Element element) =>
-      !(element is ClassElement && element.isOrInheritsProxy);
+  bool _hasProxy(Element element) =>
+      !_resolver.strongMode &&
+      element is ClassElement &&
+      element.isOrInheritsProxy;
 
   /**
    * Look for any declarations of the given [identifier] that are imported using
    * a prefix. Return the element that was found, or `null` if the name is not
    * imported using a prefix.
    */
   Element _findImportWithoutPrefix(SimpleIdentifier identifier) {
     Element element = null;
     Scope nameScope = _resolver.nameScope;
     List<ImportElement> imports = _definingLibrary.imports;
@@ skipping 198 matching lines @@
       return true;
     } else if (!_enableStrictCallChecks &&
         (type.isDartCoreFunction || type.isObject)) {
       return true;
     } else if (type is InterfaceType) {
       ClassElement classElement = type.element;
       // 16078 from Gilad: If the type is a Functor with the @proxy annotation,
       // treat it as an executable type.
       // example code: NonErrorResolverTest.
       // test_invocationOfNonFunction_proxyOnFunctionClass()
-      if (classElement.isProxy &&
+      if (!_resolver.strongMode &&
+          classElement.isProxy &&
           type.isSubtypeOf(_resolver.typeProvider.functionType)) {
         return true;
       }
       MethodElement methodElement = classElement.lookUpMethod(
           FunctionElement.CALL_METHOD_NAME, _definingLibrary);
       return methodElement != null;
     }
     return false;
   }
 
@@ skipping 214 matching lines @@
   /**
    * Record that the given [node] is undefined, causing an error to be reported
    * if appropriate. The [declaringElement] is the element inside which no
    * declaration was found. If this element is a proxy, no error will be
    * reported. If null, then an error will always be reported. The [errorCode]
    * is the error code to report. The [arguments] are the arguments to the error
    * message.
    */
   void _recordUndefinedNode(Element declaringElement, ErrorCode errorCode,
       AstNode node, List<Object> arguments) {
-    if (_doesntHaveProxy(declaringElement)) {
+    if (!_hasProxy(declaringElement)) {
       _resolver.errorReporter.reportErrorForNode(errorCode, node, arguments);
     }
   }
 
   /**
    * Record that the given [offset]/[length] is undefined, causing an error to
    * be reported if appropriate. The [declaringElement] is the element inside
    * which no declaration was found. If this element is a proxy, no error will
    * be reported. If null, then an error will always be reported. The
    * [errorCode] is the error code to report. The [arguments] are arguments to
    * the error message.
    */
   void _recordUndefinedOffset(Element declaringElement, ErrorCode errorCode,
       int offset, int length, List<Object> arguments) {
-    if (_doesntHaveProxy(declaringElement)) {
+    if (!_hasProxy(declaringElement)) {
       _resolver.errorReporter
           .reportErrorForOffset(errorCode, offset, length, arguments);
     }
   }
 
   /**
    * Record that the given [token] is undefined, causing an error to be reported
    * if appropriate. The [declaringElement] is the element inside which no
    * declaration was found. If this element is a proxy, no error will be
    * reported. If null, then an error will always be reported. The [errorCode]
    * is the error code to report. The [arguments] are arguments to the error
    * message.
    */
   void _recordUndefinedToken(Element declaringElement, ErrorCode errorCode,
       Token token, List<Object> arguments) {
-    if (_doesntHaveProxy(declaringElement)) {
+    if (!_hasProxy(declaringElement)) {
       _resolver.errorReporter.reportErrorForToken(errorCode, token, arguments);
     }
   }
 
   void _resolveAnnotationConstructorInvocationArguments(
       Annotation annotation, ConstructorElement constructor) {
     ArgumentList argumentList = annotation.arguments;
     // error will be reported in ConstantVerifier
     if (argumentList == null) {
       return;
@@ skipping 731 matching lines @@
 
   @override
   Element get staticElement => null;
 
   @override
   E accept<E>(AstVisitor<E> visitor) => null;
 
   @override
   void visitChildren(AstVisitor visitor) {}
 }