Compute NativeBehavior for native methods and fields.

pkg/compiler/lib/src/ssa/kernel_ast_adapter.dart

 // Copyright (c) 2016, 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 'package:kernel/ast.dart' as ir;
 
+import '../constants/expressions.dart';
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../constants/values.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../js_backend/backend_helpers.dart';
 import '../js_backend/js_backend.dart';
 import '../kernel/kernel.dart';
 import '../kernel/kernel_debug.dart';
@@ skipping 261 matching lines @@
       .inferredReturnTypeForElement(_backend.helpers.assertThrow, _compiler);
 
   DartType getDartType(ir.DartType type) {
     return type.accept(_typeConverter);
   }
 
   List<DartType> getDartTypes(List<ir.DartType> types) {
     return types.map(getDartType).toList();
   }
 
+  /// Computes the function type corresponding the signature of [node].
+  FunctionType getFunctionType(ir.FunctionNode node) {
+    DartType returnType = getDartType(node.returnType);
+    List<DartType> parameterTypes = <DartType>[];
+    List<DartType> optionalParameterTypes = <DartType>[];
+    for (ir.VariableDeclaration variable in node.positionalParameters) {
+      if (parameterTypes.length == node.requiredParameterCount) {
+        optionalParameterTypes.add(getDartType(variable.type));
+      } else {
+        parameterTypes.add(getDartType(variable.type));
+      }
+    }
+    List<String> namedParameters = <String>[];
+    List<DartType> namedParameterTypes = <DartType>[];
+    List<ir.VariableDeclaration> sortedNamedParameters =
+        node.namedParameters.toList()..sort((a, b) => a.name.compareTo(b.name));
+    for (ir.VariableDeclaration variable in sortedNamedParameters) {
+      namedParameters.add(variable.name);
+      namedParameterTypes.add(getDartType(variable.type));
+    }
+    return new FunctionType.synthesized(returnType, parameterTypes,
+        optionalParameterTypes, namedParameters, namedParameterTypes);
+  }
+
+  /// Converts [annotations] into a list of [ConstantExpression]s.
+  List<ConstantExpression> getMetadata(List<ir.Expression> annotations) {
+    List<ConstantExpression> metadata = <ConstantExpression>[];
+    annotations.forEach((ir.Expression node) {
+      ConstantExpression constant = node.accept(new Constantifier(this));
+      if (constant == null) {
+        throw new UnsupportedError(
+            'No constant for ${DebugPrinter.prettyPrint(node)}');
+      }
+      metadata.add(constant);
+    });
+    return metadata;
+  }
+
+  /// Compute the kind of foreign helper function called by [node], if any.
   @override
   ForeignKind getForeignKind(ir.StaticInvocation node) {
     if (isForeignLibrary(node.target.enclosingLibrary)) {
       switch (node.target.name.name) {
         case BackendHelpers.JS:
           return ForeignKind.JS;
         case BackendHelpers.JS_BUILTIN:
           return ForeignKind.JS_BUILTIN;
         case BackendHelpers.JS_EMBEDDED_GLOBAL:
           return ForeignKind.JS_EMBEDDED_GLOBAL;
         case BackendHelpers.JS_INTERCEPTOR_CONSTANT:
           return ForeignKind.JS_INTERCEPTOR_CONSTANT;
       }
     }
     return ForeignKind.NONE;
   }
 
+  /// Return `true` if [node] is the `dart:_foregin_helper` library.

[Harry Terkelsen, 2016/11/01 17:26:27]

foreign_helper

[Johnni Winther, 2016/11/02 15:16:27]

Done.

   bool isForeignLibrary(ir.Library node) {
     return node.importUri == BackendHelpers.DART_FOREIGN_HELPER;
   }
 
+  /// Looks up [typeName] for use in the spec-string of a `JS` called.
+  // TODO(johnniwinther): Use this in [NativeBehavior] instead of calling the
+  // `ForeignResolver`.
+  // TODO(johnniwinther): Cache the result to avoid redundany lookups?

[Harry Terkelsen, 2016/11/01 17:26:27]

redundant

[Johnni Winther, 2016/11/02 15:16:27]

Done.

   DartType _typeLookup(String typeName) {
     DartType findIn(Uri uri) {
       LibraryElement library = _compiler.libraryLoader.lookupLibrary(uri);
       if (library != null) {
         Element element = library.find(typeName);
         if (element != null && element.isClass) {
           ClassElement cls = element;
           return cls.rawType;
         }
       }
       return null;
     }
 
     DartType type = findIn(Uris.dart_core);
     type ??= findIn(BackendHelpers.DART_JS_HELPER);
     type ??= findIn(BackendHelpers.DART_INTERCEPTORS);
     type ??= findIn(BackendHelpers.DART_ISOLATE_HELPER);
     type ??= findIn(Uris.dart_collection);
     type ??= findIn(Uris.dart_html);
     return type;
   }
 
+  /// Computes the [NativeBehavior] for a call to the [JS] function.
+  // TODO(johnniwinther): Cache this for later use.
   NativeBehavior getNativeBehaviorForJsCall(ir.StaticInvocation node) {
     if (node.arguments.positional.length < 2 ||
         node.arguments.named.isNotEmpty) {
       reporter.reportErrorMessage(
           CURRENT_ELEMENT_SPANNABLE, MessageKind.WRONG_ARGUMENT_FOR_JS);
       return new NativeBehavior();
     }
     String specString = node.arguments.positional[0].accept(new Stringifier());
     if (specString == null) {
       reporter.reportErrorMessage(
           CURRENT_ELEMENT_SPANNABLE, MessageKind.WRONG_ARGUMENT_FOR_JS_FIRST);
       return new NativeBehavior();
     }
 
     String codeString = node.arguments.positional[1].accept(new Stringifier());
     if (codeString == null) {
       reporter.reportErrorMessage(
           CURRENT_ELEMENT_SPANNABLE, MessageKind.WRONG_ARGUMENT_FOR_JS_SECOND);
       return new NativeBehavior();
     }
 
     return NativeBehavior.ofJsCall(specString, codeString, _typeLookup,
         CURRENT_ELEMENT_SPANNABLE, reporter, _compiler.coreTypes);
   }
 
+  /// Computes the [NativeBehavior] for a call to the [JS_BUILTIN] function.
+  // TODO(johnniwinther): Cache this for later use.
   NativeBehavior getNativeBehaviorForJsBuiltinCall(ir.StaticInvocation node) {
     if (node.arguments.positional.length < 1) {
       reporter.internalError(
           CURRENT_ELEMENT_SPANNABLE, "JS builtin expression has no type.");
       return new NativeBehavior();
     }
     if (node.arguments.positional.length < 2) {
       reporter.internalError(
           CURRENT_ELEMENT_SPANNABLE, "JS builtin is missing name.");
       return new NativeBehavior();
     }
     String specString = node.arguments.positional[0].accept(new Stringifier());
     if (specString == null) {
       reporter.internalError(
           CURRENT_ELEMENT_SPANNABLE, "Unexpected first argument.");
       return new NativeBehavior();
     }
     return NativeBehavior.ofJsBuiltinCall(specString, _typeLookup,
         CURRENT_ELEMENT_SPANNABLE, reporter, _compiler.coreTypes);
   }
 
+  /// Computes the [NativeBehavior] for a call to the [JS_EMBEDDED_GLOBAL]
+  /// function.
+  // TODO(johnniwinther): Cache this for later use.
   NativeBehavior getNativeBehaviorForJsEmbeddedGlobalCall(
       ir.StaticInvocation node) {
     if (node.arguments.positional.length < 1) {
       reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
           "JS embedded global expression has no type.");
       return new NativeBehavior();
     }
     if (node.arguments.positional.length < 2) {
       reporter.internalError(
           CURRENT_ELEMENT_SPANNABLE, "JS embedded global is missing name.");
       return new NativeBehavior();
     }
     if (node.arguments.positional.length > 2 ||
         node.arguments.named.isNotEmpty) {
       reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
           "JS embedded global has more than 2 arguments.");
       return new NativeBehavior();
     }
     String specString = node.arguments.positional[0].accept(new Stringifier());
     if (specString == null) {
       reporter.internalError(
           CURRENT_ELEMENT_SPANNABLE, "Unexpected first argument.");
       return new NativeBehavior();
     }
     return NativeBehavior.ofJsEmbeddedGlobalCall(specString, _typeLookup,
         CURRENT_ELEMENT_SPANNABLE, reporter, _compiler.coreTypes);
   }
+
+  /// Returns `true` is [node] has a `@Native(...)` annotation.
+  // TODO(johnniwinther): Cache this for later use.
+  bool isNative(ir.Class node) {
+    for (ir.Expression annotation in node.annotations) {
+      if (annotation is ir.ConstructorInvocation) {
+        ConstructorElement target = getElement(annotation.target).declaration;
+        if (target.enclosingClass ==
+            _compiler.commonElements.nativeAnnotationClass) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  /// Computes the native behavior for reading the native [field].
+  // TODO(johnniwinther): Cache this for later use.
+  NativeBehavior getNativeBehaviorForFieldLoad(ir.Field field) {
+    DartType type = getDartType(field.type);
+    List<ConstantExpression> metadata = getMetadata(field.annotations);
+    return NativeBehavior.ofFieldLoad(
+        CURRENT_ELEMENT_SPANNABLE, type, metadata, _typeLookup, _compiler,
+        isJsInterop: false);
+  }
+
+  /// Computes the native behavior for writing to the native [field].
+  // TODO(johnniwinther): Cache this for later use.
+  NativeBehavior getNativeBehaviorForFieldStore(ir.Field field) {
+    DartType type = getDartType(field.type);
+    return NativeBehavior.ofFieldStore(type, _compiler.resolution);
+  }
+
+  /// Computes the native behavior for calling [procedure].
+  // TODO(johnniwinther): Cache this for later use.
+  NativeBehavior getNativeBehaviorForMethod(ir.Procedure procedure) {
+    DartType type = getFunctionType(procedure.function);
+    List<ConstantExpression> metadata = getMetadata(procedure.annotations);
+    return NativeBehavior.ofMethod(
+        CURRENT_ELEMENT_SPANNABLE, type, metadata, _typeLookup, _compiler,
+        isJsInterop: false);
+  }
 }
 
+/// Kinds of foreign functions.
 enum ForeignKind {
   JS,
   JS_BUILTIN,
   JS_EMBEDDED_GLOBAL,
   JS_INTERCEPTOR_CONSTANT,
   NONE,
 }
 
+/// Visitor that converts kernel dart types into [DartType].
 class DartTypeConverter extends ir.DartTypeVisitor<DartType> {
   final KernelAstAdapter astAdapter;
 
   DartTypeConverter(this.astAdapter);
 
   DartType visitType(ir.DartType type) => type.accept(this);
 
   List<DartType> visitTypes(List<ir.DartType> types) {
     return new List.generate(
         types.length, (int index) => types[index].accept(this));
@@ skipping 62 matching lines @@
   String visitStringConcatenation(ir.StringConcatenation node) {
     StringBuffer sb = new StringBuffer();
     for (ir.Expression expression in node.expressions) {
       String value = expression.accept(this);
       if (value == null) return null;
       sb.write(value);
     }
     return sb.toString();
   }
 }
+
+/// Visitor that converts a kernel constant expression into a
+/// [ConstantExpression].
+class Constantifier extends ir.ExpressionVisitor<ConstantExpression> {
+  final KernelAstAdapter astAdapter;
+
+  Constantifier(this.astAdapter);
+
+  @override
+  ConstantExpression visitConstructorInvocation(ir.ConstructorInvocation node) {
+    ConstructorElement constructor =
+        astAdapter.getElement(node.target).declaration;

[Harry Terkelsen, 2016/11/01 17:26:27]

it seems like 'getElement(...).declaration' is common enough that
KernelAstAdapter should have getDeclaration. What do you think?

[Johnni Winther, 2016/11/02 15:16:27]

Agree. In progress in https://codereview.chromium.org/2464103002/

+    List<DartType> typeArguments = <DartType>[];
+    for (ir.DartType type in node.arguments.types) {
+      typeArguments.add(astAdapter.getDartType(type));
+    }
+    List<ConstantExpression> arguments = <ConstantExpression>[];
+    List<String> argumentNames = <String>[];
+    for (ir.Expression argument in node.arguments.positional) {
+      ConstantExpression constant = argument.accept(this);
+      if (constant == null) return null;
+      arguments.add(constant);
+    }
+    for (ir.NamedExpression argument in node.arguments.named) {
+      argumentNames.add(argument.name);
+      ConstantExpression constant = argument.value.accept(this);
+      if (constant == null) return null;
+      arguments.add(constant);
+    }
+    return new ConstructedConstantExpression(
+        constructor.enclosingClass.thisType.createInstantiation(typeArguments),
+        constructor,
+        new CallStructure(
+            node.arguments.positional.length + argumentNames.length,
+            argumentNames),
+        arguments);
+  }
+
+  @override
+  ConstantExpression visitStringLiteral(ir.StringLiteral node) {
+    return new StringConstantExpression(node.value);
+  }
+}