dart2js/kernel: Implement type literal and JS_INTERCEPTOR_CONSTANT

pkg/compiler/lib/src/ssa/builder_kernel.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 '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart';
-import '../constants/values.dart' show StringConstantValue;
+import '../constants/values.dart'
+    show
+        ConstantValue,
+        InterceptorConstantValue,
+        StringConstantValue,
+        TypeConstantValue;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../io/source_information.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend.dart' show JavaScriptBackend;
 import '../kernel/kernel.dart';
 import '../native/native.dart' as native;
 import '../resolution/tree_elements.dart';
 import '../tree/dartstring.dart';
 import '../tree/nodes.dart' show FunctionExpression, Node;
@@ skipping 838 matching lines @@
 
   @override
   void visitMapEntry(ir.MapEntry mapEntry) {
     // Visit value before the key because each will push an expression to the
     // stack, so when we pop them off, the key is popped first, then the value.
     mapEntry.value.accept(this);
     mapEntry.key.accept(this);
   }
 
   @override
+  void visitTypeLiteral(ir.TypeLiteral typeLiteral) {
+    ir.DartType type = typeLiteral.type;
+    if (type is ir.InterfaceType) {
+      ConstantValue constant = astAdapter.getConstantForType(type);
+      stack.add(graph.addConstant(constant, compiler));
+      return;
+    }
+    if (type is ir.TypeParameterType) {
+      // TODO(27394): Load type parameter from current 'this' object.
+      defaultExpression(typeLiteral);
+      return;
+    }
+    // TODO(27394): 'dynamic' and function types observed. Where are they from?
+    defaultExpression(typeLiteral);
+    return;
+  }
+
+  @override
   void visitStaticGet(ir.StaticGet staticGet) {
     ir.Member staticTarget = staticGet.target;
     if (staticTarget is ir.Procedure &&
         staticTarget.kind == ir.ProcedureKind.Getter) {
       // Invoke the getter
       _pushStaticInvocation(staticTarget, const <HInstruction>[],
           astAdapter.returnTypeOf(staticTarget));
     } else if (staticTarget is ir.Field && staticTarget.isConst) {
       assert(staticTarget.initializer != null);
       stack.add(graph.addConstant(
@@ skipping 423 matching lines @@
       default:
         compiler.reporter.reportErrorMessage(
             astAdapter.getNode(invocation),
             MessageKind.GENERIC,
             {'text': 'Error: Unknown internal flag "$name".'});
     }
     stack.add(graph.addConstantBool(value, compiler));
   }
 
   void handleJsInterceptorConstant(ir.StaticInvocation invocation) {
-    unhandledForeign(invocation);
+    // Single argument must be a TypeConstant which is converted into a
+    // InterceptorConstant.
+    if (_unexpectedForeignArguments(invocation, 1, 1)) {
+      stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
+      return;
+    }
+    ir.Expression argument = invocation.arguments.positional.single;
+    argument.accept(this);
+    HInstruction argumentInstruction = pop();
+    if (argumentInstruction is HConstant) {
+      ConstantValue argumentConstant = argumentInstruction.constant;
+      if (argumentConstant is TypeConstantValue) {
+        // TODO(sra): Check that type is a subclass of [Interceptor].
+        ConstantValue constant =
+            new InterceptorConstantValue(argumentConstant.representedType);
+        HInstruction instruction = graph.addConstant(constant, compiler);
+        stack.add(instruction);
+        return;
+      }
+    }
+
+    compiler.reporter.reportErrorMessage(astAdapter.getNode(invocation),
+        MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
+    stack.add(graph.addConstantNull(compiler));
   }
 
   void handleForeignJs(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 2)) {
       stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
       return;
     }
 
     native.NativeBehavior nativeBehavior =
         astAdapter.getNativeBehavior(invocation);
@@ skipping 182 matching lines @@
     push(new HNot(popBoolified(), backend.boolType));
   }
 
   @override
   void visitStringConcatenation(ir.StringConcatenation stringConcat) {
     KernelStringBuilder stringBuilder = new KernelStringBuilder(this);
     stringConcat.accept(stringBuilder);
     stack.add(stringBuilder.result);
   }
 }