Handle Creates and Returns annotations in KernelBehaviorBuilder

pkg/compiler/lib/src/native/behavior.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.
 
 import '../common.dart';
 import '../common/backend_api.dart' show BackendClasses, ForeignResolver;
 import '../common/resolution.dart' show ParsingContext, Resolution;
 import '../compiler.dart' show Compiler;
 import '../compile_time_constants.dart' show ConstantEnvironment;
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../core_types.dart' show CommonElements;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart';
 import '../elements/types.dart';
 import '../js/js.dart' as js;
 import '../js_backend/js_backend.dart';
 import '../js_backend/backend_helpers.dart';
 import '../options.dart';
 import '../tree/tree.dart';
 import '../universe/side_effects.dart' show SideEffects;
 import '../util/util.dart';
 import 'js.dart';
 
-typedef dynamic /*DartType|SpecialType*/ TypeLookup(String typeString);
+typedef dynamic /*DartType|SpecialType*/ TypeLookup(String typeString,
+    {bool required});
 
 /// This class is a temporary work-around until we get a more powerful DartType.
 class SpecialType {
   final String name;
   const SpecialType._(this.name);
 
   /// The type Object, but no subtypes:
   static const JsObject = const SpecialType._('=Object');
 
   int get hashCode => name.hashCode;
@@ skipping 273 matching lines @@
         }
         return;
       }
       if (typesString == '' || typesString == 'var') {
         if (onVar != null) {
           onVar();
         }
         return;
       }
       for (final typeString in typesString.split('|')) {
-        onType(_parseType(typeString.trim(), spannable, reporter, lookupType));
+        onType(_parseType(typeString.trim(), lookupType));
       }
     }
 
     if (!specString.contains(';') && !specString.contains(':')) {
       // Form (1), types or pseudo-types like 'void' and 'var'.
       resolveTypesString(specString.trim(), onVar: () {
         typesReturned.add(objectType);
         typesReturned.add(nullType);
       }, onType: (type) {
         typesInstantiated.add(type);
@@ skipping 161 matching lines @@
             reportError("Unrecognized side-effect flag: '$dependency'.");
         }
       }
     }
 
     return sideEffects;
   }
 
   /// Returns a [TypeLookup] that uses [resolver] to perform lookup and [node]
   /// as position for errors.
-  static TypeLookup _typeLookup(Node node, ForeignResolver resolver) {
-    return (String name) => resolver.resolveTypeFromString(node, name);
+  static TypeLookup _typeLookup(
+      Node node, DiagnosticReporter reporter, ForeignResolver resolver) {
+    ResolutionDartType lookup(String name, {bool required}) {
+      ResolutionDartType type = resolver.resolveTypeFromString(node, name);
+      if (type == null && required) {
+        reporter.reportErrorMessage(
+            node, MessageKind.GENERIC, {'text': "Type '$name' not found."});
+      }
+      return type;
+    }
+
+    return lookup;
   }
 
   /// Compute the [NativeBehavior] for a [Send] node calling the 'JS' function.
   static NativeBehavior ofJsCallSend(
       Send jsCall,
       DiagnosticReporter reporter,
       ParsingContext parsing,
       CommonElements commonElements,
       ForeignResolver resolver) {
     var argNodes = jsCall.arguments;
@@ skipping 12 matching lines @@
     var codeArgument = argNodes.tail.head;
     if (codeArgument is! StringNode || codeArgument.isInterpolation) {
       reporter.reportErrorMessage(
           codeArgument, MessageKind.WRONG_ARGUMENT_FOR_JS_SECOND);
       return new NativeBehavior();
     }
 
     String specString = specArgument.dartString.slowToString();
     String codeString = codeArgument.dartString.slowToString();
 
-    return ofJsCall(specString, codeString, _typeLookup(specArgument, resolver),
-        specArgument, reporter, commonElements);
+    return ofJsCall(
+        specString,
+        codeString,
+        _typeLookup(specArgument, reporter, resolver),
+        specArgument,
+        reporter,
+        commonElements);
   }
 
   /// Compute the [NativeBehavior] for a call to the 'JS' function with the
   /// given [specString] and [codeString] (first and second arguments).
   static NativeBehavior ofJsCall(
       String specString,
       String codeString,
       TypeLookup lookupType,
       Spannable spannable,
       DiagnosticReporter reporter,
@@ skipping 104 matching lines @@
 
     LiteralString specLiteral = argNodes.head.asLiteralString();
     if (specLiteral == null) {
       // TODO(sra): We could accept a type identifier? e.g. JS(bool, '1<2').  It
       // is not very satisfactory because it does not work for void, dynamic.
       reporter.internalError(argNodes.head, "Unexpected first argument.");
     }
 
     String specString = specLiteral.dartString.slowToString();
 
-    return ofJsBuiltinCall(specString, _typeLookup(jsBuiltinCall, resolver),
-        jsBuiltinCall, reporter, commonElements);
+    return ofJsBuiltinCall(
+        specString,
+        _typeLookup(jsBuiltinCall, reporter, resolver),
+        jsBuiltinCall,
+        reporter,
+        commonElements);
   }
 
   static NativeBehavior ofJsBuiltinCall(
       String specString,
       TypeLookup lookupType,
       Spannable spannable,
       DiagnosticReporter reporter,
       CommonElements commonElements) {
     NativeBehavior behavior = new NativeBehavior();
     behavior.sideEffects.setTo(new SideEffects());
@@ skipping 43 matching lines @@
     if (specLiteral == null) {
       // TODO(sra): We could accept a type identifier? e.g. JS(bool, '1<2').  It
       // is not very satisfactory because it does not work for void, dynamic.
       reporter.internalError(argNodes.head, "Unexpected first argument.");
     }
 
     String specString = specLiteral.dartString.slowToString();
 
     return ofJsEmbeddedGlobalCall(
         specString,
-        _typeLookup(jsEmbeddedGlobalCall, resolver),
+        _typeLookup(jsEmbeddedGlobalCall, reporter, resolver),
         jsEmbeddedGlobalCall,
         reporter,
         commonElements);
   }
 
   static NativeBehavior ofJsEmbeddedGlobalCall(
       String specString,
       TypeLookup lookupType,
       Spannable spannable,
       DiagnosticReporter reporter,
@@ skipping 12 matching lines @@
 
   static NativeBehavior ofMethodElement(
       FunctionElement element, Compiler compiler) {
     ResolutionFunctionType type = element.computeType(compiler.resolution);
     List<ConstantExpression> metadata = <ConstantExpression>[];
     for (MetadataAnnotation annotation in element.implementation.metadata) {
       annotation.ensureResolved(compiler.resolution);
       metadata.add(annotation.constant);
     }
 
-    ResolutionDartType lookup(String name) {
-      Element e = element.buildScope().lookup(name);
-      if (e == null) return null;
-      if (e is! ClassElement) return null;
-      ClassElement cls = e;
-      cls.ensureResolved(compiler.resolution);
-      return cls.thisType;
-    }
-
     BehaviorBuilder builder = new ResolverBehaviorBuilder(compiler);
-    return builder.buildMethodBehavior(type, metadata, lookup,
+    return builder.buildMethodBehavior(
+        type, metadata, lookupFromElement(compiler.resolution, element),
         isJsInterop: compiler.backend.isJsInterop(element));
   }
 
   static NativeBehavior ofFieldElementLoad(
       MemberElement element, Compiler compiler) {
     Resolution resolution = compiler.resolution;
     ResolutionDartType type = element.computeType(resolution);
     List<ConstantExpression> metadata = <ConstantExpression>[];
     for (MetadataAnnotation annotation in element.implementation.metadata) {
       annotation.ensureResolved(compiler.resolution);
       metadata.add(annotation.constant);
     }
 
-    ResolutionDartType lookup(String name) {
-      Element e = element.buildScope().lookup(name);
-      if (e == null) return null;
-      if (e is! ClassElement) return null;
-      ClassElement cls = e;
-      cls.ensureResolved(compiler.resolution);
-      return cls.thisType;
-    }
-
     BehaviorBuilder builder = new ResolverBehaviorBuilder(compiler);
-    return builder.buildFieldLoadBehavior(type, metadata, lookup,
+    return builder.buildFieldLoadBehavior(
+        type, metadata, lookupFromElement(resolution, element),
         isJsInterop: compiler.backend.isJsInterop(element));
   }
 
   static NativeBehavior ofFieldElementStore(
       MemberElement field, Compiler compiler) {
     BehaviorBuilder builder = new ResolverBehaviorBuilder(compiler);
     ResolutionDartType type = field.computeType(compiler.resolution);
     return builder.buildFieldStoreBehavior(type);
   }
 
-  static dynamic /*DartType|SpecialType*/ _parseType(String typeString,
-      Spannable spannable, DiagnosticReporter reporter, TypeLookup lookupType) {
+  static TypeLookup lookupFromElement(Resolution resolution, Element element) {
+    ResolutionDartType lookup(String name, {bool required}) {
+      Element e = element.buildScope().lookup(name);
+      if (e == null || e is! ClassElement) {
+        if (required) {
+          resolution.reporter.reportErrorMessage(element, MessageKind.GENERIC,
+              {'text': "Type '$name' not found."});
+        }
+        return null;
+      }
+      ClassElement cls = e;
+      cls.ensureResolved(resolution);
+      return cls.thisType;
+    }
+
+    return lookup;
+  }
+
+  static dynamic /*DartType|SpecialType*/ _parseType(
+      String typeString, TypeLookup lookupType) {
     if (typeString == '=Object') return SpecialType.JsObject;
     if (typeString == 'dynamic') {
       return const ResolutionDynamicType();
     }
-    var type = lookupType(typeString);
+    int index = typeString.indexOf('<');
+    var type = lookupType(typeString, required: index == -1);
     if (type != null) return type;
 
-    int index = typeString.indexOf('<');
-    if (index < 1) {
-      reporter.reportErrorMessage(spannable, MessageKind.GENERIC,
-          {'text': "Type '$typeString' not found."});
-      return const ResolutionDynamicType();
+    if (index != -1) {
+      type = lookupType(typeString.substring(0, index), required: true);
+      if (type != null) {
+        // TODO(sra): Parse type parameters.
+        return type;
+      }
     }
-    type = lookupType(typeString.substring(0, index));
-    if (type != null) {
-      // TODO(sra): Parse type parameters.
-      return type;
-    }
-    reporter.reportErrorMessage(spannable, MessageKind.GENERIC,
-        {'text': "Type '$typeString' not found."});
     return const ResolutionDynamicType();
   }
 }
 
 abstract class BehaviorBuilder {
   CommonElements get commonElements;
   BackendClasses get backendClasses;
   BackendHelpers get helpers;
   DiagnosticReporter get reporter;
   ConstantEnvironment get constants;
@@ skipping 40 matching lines @@
 
       Iterable<ConstantValue> fields = constructedObject.fields.values;
       // TODO(sra): Better validation of the constant.
       if (fields.length != 1 || !fields.single.isString) {
         reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
             'Annotations needs one string: ${constant.toStructuredText()}');
       }
       StringConstantValue specStringConstant = fields.single;
       String specString = specStringConstant.toDartString().slowToString();
       for (final typeString in specString.split('|')) {
-        var type = NativeBehavior._parseType(
-            typeString, CURRENT_ELEMENT_SPANNABLE, reporter, lookupType);
+        var type = NativeBehavior._parseType(typeString, lookupType);
         if (types == null) types = [];
         types.add(type);
       }
     }
     return types;
   }
 
   /// Models the behavior of having intances of [type] escape from Dart code
   /// into native code.
   void _escape(DartType type) {
@@ skipping 143 matching lines @@
     JavaScriptBackend backend = compiler.backend;
     return backend.helpers;
   }
 
   @override
   BackendClasses get backendClasses => compiler.backend.backendClasses;
 
   @override
   Resolution get resolution => compiler.resolution;
 }