Handle Native("...") annotations in KernelBehaviorBuilder.

pkg/compiler/lib/src/kernel/element_adapter.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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
 import '../core_types.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/types.dart';
 import '../js_backend/backend_helpers.dart';
 import '../native/native.dart' as native;
 import '../universe/call_structure.dart';
 import '../universe/selector.dart';
 import 'kernel_debug.dart';
 
 /// Interface that translates between Kernel IR nodes and entities.
 abstract class KernelElementAdapter {
   /// Access to the commonly used elements and types.
   CommonElements get commonElements;
 
+  // Access to backend helpers.
+  BackendHelpers get helpers;
+
   /// [ElementEnvironment] for library, class and member lookup.
   ElementEnvironment get elementEnvironment;
 
   /// Returns the [DartType] corresponding to [type].
   DartType getDartType(ir.DartType type);
 
   /// Returns the list of [DartType]s corresponding to [types].
   List<DartType> getDartTypes(List<ir.DartType> types);
 
   /// Returns the [InterfaceType] corresponding to [type].
@@ skipping 79 matching lines @@
   JS_BUILTIN,
   JS_EMBEDDED_GLOBAL,
   JS_INTERCEPTOR_CONSTANT,
   NONE,
 }
 
 abstract class KernelElementAdapterMixin implements KernelElementAdapter {
   DiagnosticReporter get reporter;
   FunctionType getFunctionType(ir.FunctionNode node);
   native.BehaviorBuilder get nativeBehaviorBuilder;
+  BackendHelpers _helpers;
+
+  @override
+  BackendHelpers get helpers =>
+      _helpers ??= new BackendHelpers(elementEnvironment, commonElements);
 
   @override
   Name getName(ir.Name name) {
     return new Name(
         name.name, name.isPrivate ? getLibrary(name.library) : null);
   }
 
   @override
   CallStructure getCallStructure(ir.Arguments arguments) {
     int argumentCount = arguments.positional.length + arguments.named.length;
@@ skipping 69 matching lines @@
     });
     return metadata;
   }
 
   /// Returns `true` is [node] has a `@Native(...)` annotation.
   // TODO(johnniwinther): Cache this for later use.
   bool isNativeClass(ir.Class node) {
     for (ir.Expression annotation in node.annotations) {
       if (annotation is ir.ConstructorInvocation) {
         FunctionEntity target = getConstructor(annotation.target);
-        if (target.enclosingClass == commonElements.nativeAnnotationClass) {
+        if (target.enclosingClass == helpers.nativeAnnotationClass) {
           return true;
         }
       }
     }
     return false;
   }
 
   /// Compute the kind of foreign helper function called by [node], if any.
   ForeignKind getForeignKind(ir.StaticInvocation node) {
     if (isForeignLibrary(node.target.enclosingLibrary)) {
@@ skipping 224 matching lines @@
 class Constantifier extends ir.ExpressionVisitor<ConstantExpression> {
   final KernelElementAdapter elementAdapter;
 
   Constantifier(this.elementAdapter);
 
   ConstantExpression defaultExpression(ir.Expression node) {
     throw new UnimplementedError(
         'Unimplemented constant expression $node (${node.runtimeType})');
   }
 
+  List<ConstantExpression> _computeList(List<ir.Expression> expressions) {
+    List<ConstantExpression> list = <ConstantExpression>[];
+    for (ir.Expression expression in expressions) {
+      ConstantExpression constant = expression.accept(this);
+      if (constant == null) return null;
+      list.add(constant);
+    }
+    return list;
+  }
+
   List<ConstantExpression> _computeArguments(ir.Arguments node) {
     List<ConstantExpression> arguments = <ConstantExpression>[];
     for (ir.Expression argument in node.positional) {
       ConstantExpression constant = argument.accept(this);
       if (constant == null) return null;
       arguments.add(constant);
     }
     for (ir.NamedExpression argument in node.named) {
       ConstantExpression constant = argument.value.accept(this);
       if (constant == null) return null;
@@ skipping 36 matching lines @@
   @override
   ConstantExpression visitStaticGet(ir.StaticGet node) {
     return new FieldConstantExpression(elementAdapter.getField(node.target));
   }
 
   @override
   ConstantExpression visitStringLiteral(ir.StringLiteral node) {
     return new StringConstantExpression(node.value);
   }
 
+  @override
+  ConstantExpression visitStringConcatenation(ir.StringConcatenation node) {
+    return new ConcatenateConstantExpression(_computeList(node.expressions));
+  }
+
   /// Compute the [ConstantConstructor] corresponding to the const constructor
   /// [node].
   ConstantConstructor computeConstantConstructor(ir.Constructor node) {
     assert(node.isConst);
     ir.Class cls = node.enclosingClass;
     InterfaceType type = elementAdapter.elementEnvironment
         .getThisType(elementAdapter.getClass(cls));
 
     Map<dynamic, ConstantExpression> defaultValues =
         <dynamic, ConstantExpression>{};
@@ skipping 44 matching lines @@
     }
     if (isRedirecting) {
       return new RedirectingGenerativeConstantConstructor(
           defaultValues, superConstructorInvocation);
     } else {
       return new GenerativeConstantConstructor(
           type, defaultValues, fieldMap, superConstructorInvocation);
     }
   }
 }