Compute constants from IR nodes

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 '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry;
 import '../common/names.dart';
@@ skipping 1431 matching lines @@
   }
 
   /// Loop through the cases in a switch and create a mapping of case
   /// expressions to constants.
   Map<ir.Expression, ConstantValue> _buildSwitchCaseConstants(
       ir.SwitchStatement switchStatement) {
     Map<ir.Expression, ConstantValue> constants =
         new Map<ir.Expression, ConstantValue>();
     for (ir.SwitchCase switchCase in switchStatement.cases) {
       for (ir.Expression caseExpression in switchCase.expressions) {
-        ConstantValue constant = astAdapter.getConstantFor(caseExpression);
+        ConstantValue constant = _elementMap.getConstantValue(caseExpression);
         constants[caseExpression] = constant;
       }
     }
     return constants;
   }
 
   @override
   void visitContinueSwitchStatement(
       ir.ContinueSwitchStatement switchStatement) {
     handleInTryStatement();
@@ skipping 350 matching lines @@
   }
 
   @override
   void visitStringLiteral(ir.StringLiteral stringLiteral) {
     stack.add(graph.addConstantString(stringLiteral.value, closedWorld));
   }
 
   @override
   void visitSymbolLiteral(ir.SymbolLiteral symbolLiteral) {
     stack.add(graph.addConstant(
-        astAdapter.getConstantForSymbol(symbolLiteral), closedWorld));
+        _elementMap.getConstantValue(symbolLiteral), closedWorld));
     registry?.registerConstSymbol(symbolLiteral.value);
   }
 
   @override
   void visitNullLiteral(ir.NullLiteral nullLiteral) {
     stack.add(graph.addConstantNull(closedWorld));
   }
 
   /// Set the runtime type information if necessary.
   HInstruction setListRuntimeTypeInfoIfNeeded(
@@ skipping 10 matching lines @@
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
     return callSetRuntimeTypeInfoWithTypeArguments(type, arguments, object);
   }
 
   @override
   void visitListLiteral(ir.ListLiteral listLiteral) {
     HInstruction listInstruction;
     if (listLiteral.isConst) {
       listInstruction = graph.addConstant(
-          astAdapter.getConstantFor(listLiteral), closedWorld);
+          _elementMap.getConstantValue(listLiteral), closedWorld);
     } else {
       List<HInstruction> elements = <HInstruction>[];
       for (ir.Expression element in listLiteral.expressions) {
         element.accept(this);
         elements.add(pop());
       }
       listInstruction =
           new HLiteralList(elements, commonMasks.extendableArrayType);
       add(listInstruction);
       listInstruction =
           setListRuntimeTypeInfoIfNeeded(listInstruction, listLiteral);
     }
 
     TypeMask type = _typeInferenceMap.typeOfListLiteral(
         targetElement, listLiteral, closedWorld);
     if (!type.containsAll(closedWorld)) {
       listInstruction.instructionType = type;
     }
     stack.add(listInstruction);
   }
 
   @override
   void visitMapLiteral(ir.MapLiteral mapLiteral) {
     if (mapLiteral.isConst) {
       stack.add(graph.addConstant(
-          astAdapter.getConstantFor(mapLiteral), closedWorld));
+          _elementMap.getConstantValue(mapLiteral), closedWorld));
       return;
     }
 
     // The map literal constructors take the key-value pairs as a List
     List<HInstruction> constructorArgs = <HInstruction>[];
     for (ir.MapEntry mapEntry in mapLiteral.entries) {
       mapEntry.accept(this);
       constructorArgs.add(pop());
       constructorArgs.add(pop());
     }
@@ skipping 65 matching lines @@
     // 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 || type is ir.DynamicType) {
-      ConstantValue constant = astAdapter.getConstantForType(type);
+      ConstantValue constant = _elementMap.getConstantValue(typeLiteral);
       stack.add(graph.addConstant(constant, closedWorld));
       return;
     }
     // For other types (e.g. TypeParameterType, function types from expanded
     // typedefs), look-up or construct a reified type representation and convert
     // to a RuntimeType.
 
     // TODO(sra): Convert the type logic here to use ir.DartType.
     ResolutionDartType dartType = _elementMap.getDartType(type);
     dartType = localsHandler.substInContext(dartType);
@@ skipping 12 matching lines @@
     ir.Member staticTarget = staticGet.target;
     if (staticTarget is ir.Procedure &&
         staticTarget.kind == ir.ProcedureKind.Getter) {
       FunctionEntity getter = _elementMap.getMember(staticTarget);
       // Invoke the getter
       _pushStaticInvocation(getter, const <HInstruction>[],
           _typeInferenceMap.getReturnTypeOf(getter));
     } else if (staticTarget is ir.Field &&
         (staticTarget.isConst ||
             staticTarget.isFinal && !_isLazyStatic(staticTarget))) {
-      stack.add(graph.addConstant(
-          astAdapter.getConstantFor(staticTarget.initializer), closedWorld));
+      ConstantValue value = _elementMap.getConstantValue(
+          staticTarget.initializer,
+          requireConstant: staticTarget.isConst);
+      if (value != null) {
+        stack.add(graph.addConstant(value, closedWorld));
+      } else {
+        FieldEntity field = _elementMap.getField(staticTarget);
+        push(
+            new HLazyStatic(field, _typeInferenceMap.getInferredTypeOf(field)));
+      }
     } else {
       if (_isLazyStatic(staticTarget)) {
         FieldEntity field = _elementMap.getField(staticTarget);
         push(
             new HLazyStatic(field, _typeInferenceMap.getInferredTypeOf(field)));
       } else {
         MemberEntity member = _elementMap.getMember(staticTarget);
         push(new HStatic(member, _typeInferenceMap.getInferredTypeOf(member)));
       }
     }
@@ skipping 210 matching lines @@
     for (ir.DartType type in arguments.types) {
       values.add(typeBuilder.analyzeTypeArgument(
           _elementMap.getDartType(type), sourceElement));
     }
   }
 
   HInstruction _defaultValueForParameter(ir.VariableDeclaration parameter) {
     ir.Expression initializer = parameter.initializer;
     if (initializer == null) return graph.addConstantNull(closedWorld);
     // TODO(sra): Evaluate constant in ir.Node domain.
-    ConstantValue constant =
-        astAdapter.getConstantForParameterDefaultValue(initializer);
+    ConstantValue constant = _elementMap.getConstantValue(initializer);
     if (constant == null) return graph.addConstantNull(closedWorld);
     return graph.addConstant(constant, closedWorld);
   }
 
   @override
   void visitStaticInvocation(ir.StaticInvocation invocation) {
     ir.Procedure target = invocation.target;
     if (_elementMap.isForeignLibrary(target.enclosingLibrary)) {
       handleInvokeStaticForeign(invocation, target);
       return;
     }
     FunctionEntity function = _elementMap.getMember(target);
     TypeMask typeMask = _typeInferenceMap.getReturnTypeOf(function);
 
     // TODO(sra): For JS interop external functions, use a different function to
     // build arguments.
     List<HInstruction> arguments =
         _visitArgumentsForStaticTarget(target.function, invocation.arguments);
 
     if (function is ConstructorEntity && function.isFactoryConstructor) {
       if (function.isExternal && function.isFromEnvironmentConstructor) {
         if (invocation.isConst) {
           // Just like all const constructors (see visitConstructorInvocation).
           stack.add(graph.addConstant(
-              astAdapter.getConstantFor(invocation), closedWorld));
+              _elementMap.getConstantValue(invocation), closedWorld));
         } else {
           generateUnsupportedError(
               invocation,
               '${function.enclosingClass.name}.${function.name} '
               'can only be used as a const constructor');
         }
         return;
       }
 
       // Factory constructors take type parameters; other static methods ignore
@@ skipping 685 matching lines @@
         _elementMap.getSelector(invocation),
         _elementMap.getClass(_containingClass(invocation)),
         _elementMap.getMethod(invocation.interfaceTarget),
         arguments);
   }
 
   @override
   void visitConstructorInvocation(ir.ConstructorInvocation invocation) {
     ir.Constructor target = invocation.target;
     if (invocation.isConst) {
-      ConstantValue constant = astAdapter.getConstantFor(invocation);
+      ConstantValue constant = _elementMap.getConstantValue(invocation);
       stack.add(graph.addConstant(constant, closedWorld));
       return;
     }
 
     // TODO(sra): For JS-interop targets, process arguments differently.
     List<HInstruction> arguments =
         _visitArgumentsForStaticTarget(target.function, invocation.arguments);
     ConstructorEntity constructor = _elementMap.getConstructor(target);
     ClassEntity cls = constructor.enclosingClass;
     if (backend.rtiNeed.classNeedsRti(cls)) {
@@ skipping 432 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }