Compile tearoffs of static functions as constants.

pkg/fletchc/lib/src/codegen_visitor.dart

 // Copyright (c) 2015, the Fletch 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.md file.
 
 library fletchc.codegen_visitor;
 
 import 'package:compiler/src/resolution/semantic_visitor.dart' show
     SemanticSendVisitor,
     SemanticVisitor;
 
@@ skipping 19 matching lines @@
 import 'package:compiler/src/universe/universe.dart';
 import 'package:compiler/src/util/util.dart' show Spannable;
 import 'package:compiler/src/dart_types.dart';
 
 import 'fletch_context.dart';
 
 import 'fletch_backend.dart';
 
 import 'fletch_constants.dart' show
     CompiledFunctionConstant,
-    FletchClassConstant;
+    FletchClassConstant,
+    FletchClassInstanceConstant;
 
 import '../bytecodes.dart' show
     Bytecode;
 
 import 'compiled_function.dart' show
     CompiledFunction;
 
 import 'fletch_selector.dart';
 
 import 'closure_environment.dart';
@@ skipping 131 matching lines @@
   }
 
   int allocateConstantFromNode(Node node, {TreeElements elements}) {
     ConstantExpression expression = compileConstant(
         node,
         elements: elements,
         isConst: false);
     return compiledFunction.allocateConstant(expression.value);
   }
 
+  int allocateConstantClassInstance(int classId) {
+    var constant = new FletchClassInstanceConstant(classId);
+    context.markConstantUsed(constant);

[ahe, 2015/04/07 15:00:11]

Why isn't this called for other constants?

[Anders Johnsen, 2015/04/08 06:32:14]

It is, through "compileConstant".

+    return compiledFunction.allocateConstant(constant);
+  }
+
   int allocateStringConstant(String string) {
     return compiledFunction.allocateConstant(
         context.backend.constantSystem.createString(
             new DartString.literal(string)));
   }
 
   ClosureInfo get closureInfo => closureEnvironment.closures[element];
 
   LocalValue createLocalValueFor(
       LocalElement element,
@@ skipping 506 matching lines @@
     }
     builder.identical();
   }
 
   void handleStaticFunctionGet(MethodElement function) {
     registry.registerStaticInvocation(function);
     CompiledFunction compiledFunctionTarget =
         context.backend.createCompiledFunction(function, null, null);
     CompiledClass compiledClass = context.backend.createTearoffClass(
         compiledFunctionTarget);
-    int classConstant = compiledFunction.allocateConstantFromClass(
-        compiledClass.id);
-    builder.allocate(classConstant, compiledClass.fields);
+    if (compiledClass.fields == 0) {

[ahe, 2015/04/08 08:04:18]

Why is it the number of fields that determine if you use
allocateConstantClassInstance?

You stated that the reason for using FletchClassInstanceConstant is that
compiledClass isn't a real class. Why is that the same as having no fields?

Also, when would the tearoff class have fields?

[Anders Johnsen, 2015/04/08 08:37:57]

Because the field is not a constant - it can only be a constant if it doesn't
have any fields. But in this case, we can assert it.

+      int constId = allocateConstantClassInstance(compiledClass.id);
+      builder.loadConst(constId);
+    } else {
+      int classConstant = compiledFunction.allocateConstantFromClass(
+          compiledClass.id);
+      builder.allocate(classConstant, compiledClass.fields);
+    }
   }
 
   void visitTopLevelFunctionGet(
       Send node,
       MethodElement function,
       _) {
     handleStaticFunctionGet(function);
     applyVisitState();
   }
 
@@ skipping 350 matching lines @@
       if (isTrue) {
         builder.loadLiteralTrue();
       } else {
         builder.loadLiteralFalse();
       }
     } else if (visitState == VisitState.Test) {
       builder.branch(isTrue ? trueLabel : falseLabel);
     }
   }
 
+  void visitLiteralInt(LiteralInt node) {
+    if (visitState == VisitState.Value) {
+      int value = node.value;
+      if (value >= 0x3FFFFFFF) {

[ahe, 2015/04/07 15:03:30]

0x3FFFFFFF should probably be a named constant with some documentation.

Also, what happens if value is a negative value of high magnitude?

[Anders Johnsen, 2015/04/08 06:32:13]

literal ints are never negative.

[ahe, 2015/04/08 08:04:18]

Assert that?

[Anders Johnsen, 2015/04/08 08:37:57]

Done.

+        int constId = allocateConstantFromNode(node);
+        builder.loadConst(constId);
+      } else {
+        builder.loadLiteral(value);
+      }
+    } else if (visitState == VisitState.Test) {
+      builder.branch(falseLabel);
+    }
+  }
+
   void visitLiteral(Literal node) {
     if (visitState == VisitState.Value) {
       builder.loadConst(allocateConstantFromNode(node));
     } else if (visitState == VisitState.Test) {
       builder.branch(falseLabel);
     }
   }
 
   void visitLiteralList(LiteralList node) {
     if (node.isConst) {
@@ skipping 2169 matching lines @@
 
   void errorUnresolvedSuperIndex(
       Send node,
       Element element,
       Node index,
       _) {
     generateUnimplementedError(
         node, "[errorUnresolvedSuperIndex] isn't implemented.");
   }
 }