Check for compile-time constants in DartCompiler

compiler/javatests/com/google/dart/compiler/backend/js/testFieldAccessExprOpt.dart

 // Copyright (c) 2011, 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.
 
 class A {
   int x;
 
+  const A() : this.x = 1;

[ngeoffray, 2011/10/14 09:26:56]

Why changing this file? I would keep it as is, and copy it if you want to run
the almost same code?

[zundel, 2011/10/14 10:04:21]

Part of this change is to enforce the initialization of static fields.  You
cannot initialize a static final with a non-const value.  This code was using
the implicit constructor which is not const.  I'm pretty sure this file was
intended to be valid dart code, so I updated it.

[ngeoffray, 2011/10/14 10:33:42]

I'm not sure I follow. This file looks like valid Dart code before your changes.
I don't see why you need to change the constructor to 'const' to make it valid?

[floitsch, 2011/10/14 14:36:58]

Maybe because the "static final A a = new A() (below) is invalid. Please make
sure that the checker catches this case.

[zundel, 2011/10/14 20:59:52]

It seems to me that if you add together all the places in the spec where it
talks about compile-time constant in initializers, you can only initialize a
variable with a compile-time constant, whether or not it is static or final or
non-static:

Section 7.4 instance variables
...
If an instance variable declaration has one of the forms T v = e;, var v = e;,
fi
nal T v = e; or final 
nal v = e; then the expression e must be a compile-time constant (10.1).


Section 5, (Variables)
...
A variable that is both static and fi
nal must be initialized to a compile-time constant (10.1) or a compile-time
error occurs.
Why tie together two orthogonal concepts like static and 
nal by requiring the use of constants? Because we do not want a language where
expensive initialization computations are de
ned, causing long application startup times. This is especially crucial for
Dart, which is designed for coding client applications.  One time
initializations using constants should incur negligible cost at runtime

I have code right now that pulls in the constructor being referenced and sees if
it is marked as const.  

Question:  is it legal to have both a constant and non-constant constructor in a
class?  I would think that you could only have one and it would have to be a
factory method.

class A {
  var x;
  const A(this.x);
  A(this.x) { ... do something ...}
}

[zundel, 2011/10/14 20:59:52]

Done.

+
   static final A a = new A();
 
-  A(){}
+  
 }
 
 class WillNotOptimizeFieldAccess {
   WillNotOptimizeFieldAccess(){}
   int x;
 }
 
 class WillNotOptimizeFieldAccessSubclass extends WillNotOptimizeFieldAccess {
   WillNotOptimizeFieldAccessSubclass() : super() {}
   
@@ skipping 76 matching lines @@
 
     int _marker_7 = c.XGetter;
 
     int _marker_8 = c.AXGetter;
   }
 }
 
 main() {
   Main.main();
 }