tests for inlining between IR and AST functions

sdk/lib/_internal/compiler/implementation/ir/ir_builder.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 dart2js.ir_builder;
 
 import 'ir_nodes.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart' show FunctionElementX;
 import '../dart2jslib.dart';
@@ skipping 65 matching lines @@
               LibraryElement library = element.declaration.getLibrary();
               IrConstantPool constantPool = IrConstantPool.forLibrary(library);
               List<int> data = irNode.pickle(constantPool);
               irNode = new Unpickler(compiler, constantPool).unpickle(data);
               return true;
             });
             nodes[element] = irNode;
             unlinkTreeAndToken(element);
           }
         }
+        ensureIr(element);
       });
     });
   }
 
   bool irEnabled() {
     // TODO(lry): support checked-mode checks.
     if (compiler.enableTypeAssertions ||
         compiler.backend is !JavaScriptBackend ||
         compiler.enableConcreteTypeInference) {
       return false;
@@ skipping 11 matching lines @@
     if (signature.parameterCount > 0) return false;
 
     // TODO(lry): support intercepted methods. Then the dependency on
     // JavaScriptBackend will go away.
     JavaScriptBackend backend = compiler.backend;
     if (backend.isInterceptedMethod(element)) return false;
 
     // TODO(lry): support native functions (also in [visitReturn]).
     if (function.isNative()) return false;
 
+    // Methods annotated @IrRepresentation(false).
+    if (enforceAstRepresentation(function)) return false;
+
     return true;
   }
 
+  bool get inCheckedMode {
+    bool result = false;
+    assert((result = true));
+    return result;
+  }
+
+  bool enforceAstRepresentation(Element element) {
+    return irRepresentationValue(element, false);
+  }
+
+  bool enforceIrRepresentation(Element element) {
+    return irRepresentationValue(element, true);
+  }
+
+  /**
+   * In host-checked mode, the @IrRepresentation annotation can be used to
+   * enforce the internal representation of a function.
+   */
+  bool irRepresentationValue(Element element, bool expected) {
+    if (!inCheckedMode || compiler.backend is !JavaScriptBackend) return false;
+    JavaScriptBackend backend = compiler.backend;
+    for (MetadataAnnotation metadata in element.metadata) {
+      if (!metadata.value.isConstructedObject()) continue;
+      ObjectConstant value = metadata.value;
+      ClassElement cls = value.type.element;
+      if (cls == backend.irRepresentationClass) {
+        ConstructedConstant classConstant = value;
+        BoolConstant constant = classConstant.fields[0];
+        return constant.value == expected;
+      }
+    }
+    return false;
+  }
+
+  void ensureIr(Element element) {
+    // If no IR was built for [element], ensure it is not annotated
+    // @IrRepresentation(true).
+    if (inCheckedMode &&
+        !compiler.irBuilder.hasIr(element) &&
+        enforceIrRepresentation(element)) {
+      compiler.reportFatalError(
+          element,
+          MessageKind.GENERIC,
+          {'text': "Error: cannot build IR for $element."});
+    }
+  }
+
   void unlinkTreeAndToken(element) {
     // Ensure the function signature has been computed (requires the AST).
     assert(element is !FunctionElementX || element.functionSignature != null);
-    bool isCheckedMode = false;
-    assert((isCheckedMode = true));
-    if (isCheckedMode) {
+    if (inCheckedMode) {
       element.beginToken.next = null;
       element.cachedNode = null;
     }
   }
 
   SourceFile elementSourceFile(Element element) {
     if (element is FunctionElement) {
       FunctionElement functionElement = element;
       if (functionElement.patch != null) element = functionElement.patch;
     }
@@ skipping 227 matching lines @@
 
   void exitBlock() {
     blockBuilders.removeLast();
   }
 }
 
 class BlockBuilder {
   List<IrNode> statements = <IrNode>[];
   bool hasReturn = false;
 }