Move JsInteropAnalysis.onQueueClosed to AnnotationProcessor.processJsInteropAnnotation

pkg/compiler/lib/src/resolution/resolution_strategy.dart

 // Copyright (c) 2017, 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 dart2js.resolution_strategy;
 
 import '../common.dart';
 import '../common_elements.dart';
 import '../common/backend_api.dart';
 import '../common/names.dart';
 import '../common/resolution.dart';
 import '../common/tasks.dart';
+import '../constants/values.dart';
 import '../compiler.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/modelx.dart';
 import '../elements/resolution_types.dart';
 import '../environment.dart';
 import '../enqueue.dart';
 import '../frontend_strategy.dart';
 import '../js_backend/backend.dart';
 import '../js_backend/backend_usage.dart';
@@ skipping 401 matching lines @@
 /// very early in the compilation pipeline, typically this is before resolution
 /// is complete. Because of that this processor does a lightweight parse of the
 /// annotation (which is restricted to a limited subset of the annotation
 /// syntax), and, once resolution completes, it validates that the parsed
 /// annotations correspond to the correct element.
 class _ElementAnnotationProcessor implements AnnotationProcessor {
   Compiler _compiler;
 
   _ElementAnnotationProcessor(this._compiler);
 
+  CommonElements get _commonElements => _compiler.commonElements;
+
   /// Check whether [cls] has a `@Native(...)` annotation, and if so, set its
   /// native name from the annotation.
   void extractNativeAnnotations(
       LibraryElement library, NativeBasicDataBuilder nativeBasicDataBuilder) {
     library.forEachLocalMember((Element element) {
       if (element.isClass) {
         EagerAnnotationHandler.checkAnnotation(_compiler, element,
             new NativeAnnotationHandler(nativeBasicDataBuilder));
       }
     });
@@ skipping 11 matching lines @@
     }
     library.forEachLocalMember((Element element) {
       if (element.isClass) {
         ClassElement cls = element;
         if (checkJsInteropAnnotation(element)) {
           nativeBasicDataBuilder.markAsJsInteropClass(cls);
         }
       }
     });
   }
+
+  void processJsInteropAnnotations(
+      NativeBasicData nativeBasicData, NativeDataBuilder nativeDataBuilder) {
+    if (_commonElements.jsAnnotationClass == null) return;
+
+    ClassElement cls = _commonElements.jsAnnotationClass;
+    FieldElement nameField = cls.lookupMember('name');
+
+    /// Resolves the metadata of [element] and returns the name of the `JS(...)`
+    /// annotation for js interop, if found.
+    String processJsInteropAnnotation(Element element) {
+      for (MetadataAnnotation annotation in element.implementation.metadata) {
+        // TODO(johnniwinther): Avoid processing unresolved elements.
+        if (annotation.constant == null) continue;
+        ConstantValue constant =
+            _compiler.constants.getConstantValue(annotation.constant);
+        if (constant == null || constant is! ConstructedConstantValue) continue;
+        ConstructedConstantValue constructedConstant = constant;
+        if (constructedConstant.type.element ==
+            _commonElements.jsAnnotationClass) {
+          ConstantValue value = constructedConstant.fields[nameField];
+          String name;
+          if (value.isString) {
+            StringConstantValue stringValue = value;
+            name = stringValue.primitiveValue.slowToString();
+          } else {
+            // TODO(jacobr): report a warning if the value is not a String.
+            name = '';
+          }
+          return name;
+        }
+      }
+      return null;
+    }
+
+    void checkFunctionParameters(MethodElement fn) {
+      if (fn.hasFunctionSignature &&
+          fn.functionSignature.optionalParametersAreNamed) {
+        _compiler.reporter.reportErrorMessage(
+            fn,
+            MessageKind.JS_INTEROP_METHOD_WITH_NAMED_ARGUMENTS,
+            {'method': fn.name});
+      }
+    }
+
+    bool hasAnonymousAnnotation(Element element) {
+      if (_commonElements.jsAnonymousClass == null) return false;
+      return element.metadata.any((MetadataAnnotation annotation) {
+        ConstantValue constant =
+            _compiler.constants.getConstantValue(annotation.constant);
+        if (constant == null || constant is! ConstructedConstantValue)
+          return false;
+        ConstructedConstantValue constructedConstant = constant;
+        return constructedConstant.type.element ==
+            _commonElements.jsAnonymousClass;
+      });
+    }
+
+    void processJsInteropAnnotationsInLibrary(LibraryElement library) {
+      String libraryName = processJsInteropAnnotation(library);
+      if (libraryName != null) {
+        nativeDataBuilder.setJsInteropLibraryName(library, libraryName);
+      }
+      library.implementation.forEachLocalMember((Element element) {
+        if (element is MemberElement) {
+          String memberName = processJsInteropAnnotation(element);
+          if (memberName != null) {
+            nativeDataBuilder.setJsInteropMemberName(element, memberName);
+            if (element is MethodElement) {
+              checkFunctionParameters(element);
+            }
+          }
+        }
+
+        if (!element.isClass) return;
+
+        ClassElement classElement = element;
+        String className = processJsInteropAnnotation(classElement);
+        if (className != null) {
+          nativeDataBuilder.setJsInteropClassName(classElement, className);
+        }
+        if (!nativeBasicData.isJsInteropClass(classElement)) return;
+
+        bool isAnonymous = hasAnonymousAnnotation(classElement);
+        if (isAnonymous) {
+          nativeDataBuilder.markJsInteropClassAsAnonymous(classElement);
+        }
+
+        // Skip classes that are completely unreachable. This should only happen
+        // when all of jsinterop types are unreachable from main.
+        if (!_compiler.resolutionWorldBuilder.isImplemented(classElement)) {
+          return;
+        }
+
+        if (!classElement
+            .implementsInterface(_commonElements.jsJavaScriptObjectClass)) {
+          _compiler.reporter.reportErrorMessage(classElement,
+              MessageKind.JS_INTEROP_CLASS_CANNOT_EXTEND_DART_CLASS, {
+            'cls': classElement.name,
+            'superclass': classElement.superclass.name
+          });
+        }
+
+        classElement
+            .forEachMember((ClassElement classElement, MemberElement member) {
+          String memberName = processJsInteropAnnotation(member);
+          if (memberName != null) {
+            nativeDataBuilder.setJsInteropMemberName(member, memberName);
+          }
+
+          if (!member.isSynthesized &&
+              nativeBasicData.isJsInteropClass(classElement) &&
+              member is MethodElement) {
+            MethodElement fn = member;
+            if (!fn.isExternal &&
+                !fn.isAbstract &&
+                !fn.isConstructor &&
+                !fn.isStatic) {
+              _compiler.reporter.reportErrorMessage(
+                  fn,
+                  MessageKind.JS_INTEROP_CLASS_NON_EXTERNAL_MEMBER,
+                  {'cls': classElement.name, 'member': member.name});
+            }
+
+            if (fn.isFactoryConstructor && isAnonymous) {
+              fn.functionSignature
+                  .orderedForEachParameter((ParameterElement parameter) {
+                if (!parameter.isNamed) {
+                  _compiler.reporter.reportErrorMessage(
+                      parameter,
+                      MessageKind
+                          .JS_OBJECT_LITERAL_CONSTRUCTOR_WITH_POSITIONAL_ARGUMENTS,
+                      {'parameter': parameter.name, 'cls': classElement.name});
+                }
+              });
+            } else {
+              checkFunctionParameters(fn);
+            }
+          }
+        });
+      });
+    }
+
+    _compiler.libraryLoader.libraries
+        .forEach(processJsInteropAnnotationsInLibrary);
+  }
 }