check that Class and typedef refs are const

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.
 
 library dart2js.resolution.members;
 
 import '../common.dart';
 import '../common/names.dart' show Selectors;
 import '../common/resolution.dart' show Feature;
 import '../compiler.dart' show Compiler;
@@ skipping 1978 matching lines @@
     registry.useElement(node, element);
     registry.registerTypeLiteral(node, type);
 
     if (node.isCall) {
       CallStructure callStructure =
           resolveArguments(node.argumentsNode).callStructure;
       Selector selector = callStructure.callSelector;
       // TODO(23998): Remove this when all information goes through
       // the [SendStructure].
       registry.setSelector(node, selector);
-
-      // The node itself is not a constant but we register the selector (the
-      // identifier that refers to the class/typedef) as a constant.
+      
       registry.useElement(node.selector, element);
-      analyzeConstantDeferred(node.selector, enforceConst: false);
+      analyzeConstantDeferred(node.selector);
 
       registry.registerSendStructure(
           node, new InvokeStructure(semantics, selector));
       return const NoneResult();
     } else {
-      analyzeConstantDeferred(node, enforceConst: false);
+      analyzeConstantDeferred(node);
 
       registry.setConstant(node, semantics.constant);
       registry.registerSendStructure(node, new GetStructure(semantics));
       return new ConstantResult(node, semantics.constant);
     }
   }
 
   /// Handle access to a constant type literal of [type].
   // TODO(johnniwinther): Remove [name] when [Selector] is not required for the
   // the [GetStructure].
@@ skipping 1973 matching lines @@
       ClassElement cls = keyType.element;
       if (cls == coreClasses.stringClass) continue;
       Element equals = cls.lookupMember('==');
       if (equals.enclosingClass != coreClasses.objectClass) {
         reporter.reportErrorMessage(spannable,
             MessageKind.CONST_MAP_KEY_OVERRIDES_EQUALS, {'type': keyType});
       }
     }
   }
 
-  void analyzeConstant(Node node, {enforceConst: true}) {
-    ConstantExpression constant = compiler.resolver.constantCompiler
-        .compileNode(node, registry.mapping, enforceConst: enforceConst);
+  void analyzeConstant(Node node) {
+    ConstantExpression constant =
+        compiler.resolver.constantCompiler.compileNode(node, registry.mapping);
 
     if (constant == null) {
       assert(invariant(node, compiler.compilationFailed));
       return;
     }
 
     ConstantValue value = compiler.constants.getConstantValue(constant);
     if (value.isMap) {
       checkConstMapKeysDontOverrideEquals(node, value);
     }
   }
 
-  void analyzeConstantDeferred(Node node,
-      {bool enforceConst: true, void onAnalyzed()}) {
+  void analyzeConstantDeferred(Node node, {void onAnalyzed()}) {
     addDeferredAction(enclosingElement, () {
-      analyzeConstant(node, enforceConst: enforceConst);
+      analyzeConstant(node);
       if (onAnalyzed != null) {
         onAnalyzed();
       }
     });
   }
 
   bool validateSymbol(Node node, String name, {bool reportError: true}) {
     if (name.isEmpty) return true;
     if (name.startsWith('_')) {
       if (reportError) {
@@ skipping 694 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(
     DiagnosticReporter reporter, Node node, Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), reporter, node);
 }