Register literals through backend.

dart/pkg/compiler/lib/src/resolution/members.dart

 // Copyright (c) 2012, 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.
 
 part of resolution;
 
 abstract class TreeElements {
   AnalyzableElement get analyzedElement;
   Iterable<Node> get superUses;
 
@@ skipping 679 matching lines @@
     Modifiers modifiers = element.modifiers;
     if (initializer != null) {
       // TODO(johnniwinther): Avoid analyzing initializers if
       // [Compiler.analyzeSignaturesOnly] is set.
       visitor.visit(initializer);
     } else if (modifiers.isConst) {
       compiler.reportError(element, MessageKind.CONST_WITHOUT_INITIALIZER);
     } else if (modifiers.isFinal && !element.isInstanceMember) {
       compiler.reportError(element, MessageKind.FINAL_WITHOUT_INITIALIZER);
     } else {
-      registry.registerInstantiatedClass(compiler.nullClass);
+      registry.registerLiteralNull();
     }
 
     if (Elements.isStaticOrTopLevelField(element)) {
       visitor.addDeferredAction(element, () {
         if (element.modifiers.isConst) {
           constantCompiler.compileConstant(element);
         } else {
           constantCompiler.compileVariable(element);
         }
       });
@@ skipping 1811 matching lines @@
     // Run the body in a fresh statement scope.
     StatementScope oldStatementScope = statementScope;
     statementScope = new StatementScope();
     visit(node.body);
     statementScope = oldStatementScope;
 
     scope = oldScope;
     enclosingElement = previousEnclosingElement;
 
     registry.registerClosure(function);
-    registry.registerInstantiatedClass(compiler.functionClass);
+    registry.registerLiteralFunction();
   }
 
   visitIf(If node) {
     doInPromotionScope(node.condition.expression, () => visit(node.condition));
     doInPromotionScope(node.thenPart,
         () => visitIn(node.thenPart, new BlockScope(scope)));
     visitIn(node.elsePart, new BlockScope(scope));
   }
 
   ResolutionResult resolveSend(Send node) {
@@ skipping 502 matching lines @@
 
       // Make sure we include the + and - operators if we are using
       // the ++ and -- ones.  Also, if op= form is used, include op itself.
       void registerBinaryOperator(String name) {
         Selector binop = new Selector.binaryOperator(name);
         registry.registerDynamicInvocation(binop);
         registry.setOperatorSelectorInComplexSendSet(node, binop);
       }
       if (identical(source, '++')) {
         registerBinaryOperator('+');
-        registry.registerInstantiatedClass(compiler.intClass);
+        registry.registerLiteralInt();
       } else if (identical(source, '--')) {
         registerBinaryOperator('-');
-        registry.registerInstantiatedClass(compiler.intClass);
+        registry.registerLiteralInt();
       } else if (source.endsWith('=')) {
         registerBinaryOperator(Elements.mapToUserOperator(operatorName));
       }
     }
 
     registerSend(selector, setter);
     return new ElementResult(registry.useElement(node, setter));
   }
 
   void registerSend(Selector selector, Element target) {
@@ skipping 10 matching lines @@
       // instead resolved through their enclosing type declaration.
       if (!target.isTypeVariable) {
         // [target] might be the implementation element and only declaration
         // elements may be registered.
         registry.registerStaticUse(target.declaration);
       }
     }
   }
 
   visitLiteralInt(LiteralInt node) {
-    registry.registerInstantiatedClass(compiler.intClass);
+    registry.registerLiteralInt();
   }
 
   visitLiteralDouble(LiteralDouble node) {
-    registry.registerInstantiatedClass(compiler.doubleClass);
+    registry.registerLiteralDouble();
   }
 
   visitLiteralBool(LiteralBool node) {
-    registry.registerInstantiatedClass(compiler.boolClass);
+    registry.registerLiteralBool();
   }
 
   visitLiteralString(LiteralString node) {
-    registry.registerInstantiatedClass(compiler.stringClass);
+    registry.registerLiteralString();
   }
 
   visitLiteralNull(LiteralNull node) {
-    registry.registerInstantiatedClass(compiler.nullClass);
+    registry.registerLiteralNull();
   }
 
   visitLiteralSymbol(LiteralSymbol node) {
-    registry.registerInstantiatedClass(compiler.symbolClass);
-    registry.registerStaticUse(compiler.symbolConstructor.declaration);
-    registry.registerConstSymbol(node.slowNameString);
+    registry.registerLiteralSymbol(node.slowNameString);
     if (!validateSymbol(node, node.slowNameString, reportError: false)) {
       compiler.reportError(node,
           MessageKind.UNSUPPORTED_LITERAL_SYMBOL,
           {'value': node.slowNameString});
     }
     analyzeConstantDeferred(node);
   }
 
   visitStringJuxtaposition(StringJuxtaposition node) {
-    registry.registerInstantiatedClass(compiler.stringClass);
+    registry.registerLiteralString();
     node.visitChildren(this);
   }
 
   visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
       visit(link.head);
     }
   }
 
   visitOperator(Operator node) {
@@ skipping 385 matching lines @@
     sendIsMemberAccess = false;
   }
 
   visitConditional(Conditional node) {
     doInPromotionScope(node.condition, () => visit(node.condition));
     doInPromotionScope(node.thenExpression, () => visit(node.thenExpression));
     visit(node.elseExpression);
   }
 
   visitStringInterpolation(StringInterpolation node) {
-    registry.registerInstantiatedClass(compiler.stringClass);
+    registry.registerLiteralString();
     registry.registerStringInterpolation();
     node.visitChildren(this);
   }
 
   visitStringInterpolationPart(StringInterpolationPart node) {
     registerImplicitInvocation('toString', 0);
     node.visitChildren(this);
   }
 
   visitBreakStatement(BreakStatement node) {
@@ skipping 444 matching lines @@
       DartType exceptionType = registry.getType(node.type);
       Node exceptionVariable = exceptionDefinition.definitions.nodes.head;
       VariableElementX exceptionElement =
           registry.getDefinition(exceptionVariable);
       exceptionElement.variables.type = exceptionType;
     }
     if (stackTraceDefinition != null) {
       Node stackTraceVariable = stackTraceDefinition.definitions.nodes.head;
       VariableElementX stackTraceElement =
           registry.getDefinition(stackTraceVariable);
-      registry.registerInstantiatedClass(compiler.stackTraceClass);
       stackTraceElement.variables.type = compiler.stackTraceClass.rawType;
     }
   }
 
   visitTypedef(Typedef node) {
     internalError(node, 'typedef');
   }
 }
 
 class TypeDefinitionVisitor extends MappingVisitor<DartType> {
@@ skipping 772 matching lines @@
     if (scope.variableReferencedInInitializer) {
       compiler.reportError(
           identifier, MessageKind.REFERENCE_IN_INITIALIZATION,
           {'variableName': name});
     }
     return identifier;
   }
 
   Identifier visitIdentifier(Identifier node) {
     // The variable is initialized to null.
-    registry.registerInstantiatedClass(compiler.nullClass);
+    registry.registerLiteralNull();
     if (definitions.modifiers.isConst) {
       compiler.reportError(node, MessageKind.CONST_WITHOUT_INITIALIZER);
     }
     if (definitions.modifiers.isFinal &&
         !resolver.allowFinalWithoutInitializer) {
       compiler.reportError(node, MessageKind.FINAL_WITHOUT_INITIALIZER);
     }
     return node;
   }
 
@@ skipping 265 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }