Refactor ConstantExpression/ConstantConstructor to use entities.

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:js_runtime/shared/embedded_names.dart';
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
@@ skipping 546 matching lines @@
 
   ResolutionInterfaceType getInterfaceType(ir.InterfaceType type) =>
       getDartType(type);
 
   ResolutionInterfaceType createInterfaceType(
       ir.Class cls, List<ir.DartType> typeArguments) {
     return new ResolutionInterfaceType(
         getClass(cls), getDartTypes(typeArguments));
   }
 
-  /// 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;
-  }
-
   @override
   LibraryEntity lookupLibrary(Uri uri) {
     return _compiler.libraryLoader.lookupLibrary(uri);
   }
 
   @override
   ClassElement lookupClass(LibraryElement library, String name) {
     Element element = library.find(name);
     if (element != null && element.isClass) {
       return element;
@@ skipping 132 matching lines @@
   ResolutionDartType visitInvalidType(ir.InvalidType node) {
     if (topLevel) {
       throw new UnimplementedError(
           "Outermost invalid types not currently supported");
     }
     // Nested invalid types are treated as `dynamic`.
     return const ResolutionDynamicType();
   }
 }
 
-/// 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;
-    List<ResolutionDartType> typeArguments = <ResolutionDartType>[];
-    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 visitStaticGet(ir.StaticGet node) {
-    Element element = astAdapter.getMember(node.target);
-    if (element.isField) {
-      return new VariableConstantExpression(element);
-    }
-    astAdapter.reporter.internalError(
-        CURRENT_ELEMENT_SPANNABLE, "Unexpected constant target: $element.");
-    return null;
-  }
-
-  @override
-  ConstantExpression visitStringLiteral(ir.StringLiteral node) {
-    return new StringConstantExpression(node.value);
-  }
-}
-
 class KernelJumpTarget extends JumpTarget {
   static int index = 0;
 
   /// Pointer to the actual executable statements that a jump target refers to.
   /// If this jump target was not initially constructed with a LabeledStatement,
   /// this value is identical to originalStatement.
   // TODO(efortuna): In an ideal world the Node should be some common
   // interface we create for both ir.Statements and ir.SwitchCase (the
   // ContinueSwitchStatement's target is a SwitchCase) rather than general
   // Node. Talking to Asger about this.
@@ skipping 96 matching lines @@
       JumpTarget continueTarget =
           astAdapter.getJumpTarget(switchCase, isContinueTarget: true);
       assert(continueTarget is KernelJumpTarget);
       targetIndexMap[continueTarget] = switchIndex;
       assert(builder.jumpTargets[continueTarget] == null);
       builder.jumpTargets[continueTarget] = this;
       switchIndex++;
     }
   }
 }