Build new IR for functions returning a constant

sdk/lib/_internal/compiler/implementation/elements/modelx.dart

 // Copyright (c) 2013, 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 elements.modelx;
 
 import 'elements.dart';
 import '../../compiler.dart' as api;
 import '../tree/tree.dart';
 import '../util/util.dart';
@@ skipping 11 matching lines @@
                                  FunctionType,
                                  Selector,
                                  Constant,
                                  Compiler,
                                  isPrivateName;
 
 import '../dart_types.dart';
 
 import '../scanner/scannerlib.dart' show Token, EOF_TOKEN;
 
+import '../ir/ir_nodes.dart' show IrNode, IrFunction;
 
 class ElementX implements Element {
   static int elementHashCode = 0;
 
   final String name;
   final ElementKind kind;
   final Element enclosingElement;
   final int hashCode = ++elementHashCode;
   Link<MetadataAnnotation> metadata = const Link<MetadataAnnotation>();
 
   ElementX(this.name, this.kind, this.enclosingElement) {
     assert(isErroneous() || getImplementationLibrary() != null);
   }
 
   Modifiers get modifiers => Modifiers.EMPTY;
 
   Node parseNode(DiagnosticListener listener) {
     listener.internalErrorOnElement(this, 'not implemented');
   }
 
   DartType computeType(Compiler compiler) {
     compiler.internalError("$this.computeType.", token: position());
   }
 
+  bool hasIrNode(Compiler compiler) => false;
+
+  IrNode irNode(Compiler compiler) {
+    compiler.internalError("$this.irNode.", token: position());
+  }
+
   void addMetadata(MetadataAnnotation annotation) {
     assert(annotation.annotatedElement == null);
     annotation.annotatedElement = this;
     metadata = metadata.prepend(annotation);
   }
 
   bool isFunction() => identical(kind, ElementKind.FUNCTION);
   bool isConstructor() => isFactoryConstructor() || isGenerativeConstructor();
   bool isClosure() => false;
   bool isMember() {
@@ skipping 1375 matching lines @@
         _hasNoBody = hasNoBody {
     assert(modifiers != null);
     defaultImplementation = this;
   }
 
   bool get isPatched => patch != null;
   bool get isPatch => origin != null;
 
   bool get isRedirectingFactory => defaultImplementation != this;
 
+  bool hasIrNode(Compiler compiler) {
+    return compiler.irBuilder.nodes.containsKey(this);
+  }
+
+  IrNode irNode(Compiler compiler) => compiler.irBuilder.nodes[this];
+
   /// This field is set by the post process queue when checking for cycles.
   FunctionElement internalRedirectionTarget;
   DartType redirectionTargetType;
 
   set redirectionTarget(FunctionElement constructor) {
     assert(constructor != null && internalRedirectionTarget == null);
     internalRedirectionTarget = constructor;
   }
 
   FunctionElement get redirectionTarget {
@@ skipping 920 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }