Check for compile-time constants in DartCompiler

compiler/java/com/google/dart/compiler/resolver/Resolver.java

 // 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.
 
 package com.google.dart.compiler.resolver;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.Sets;
 import com.google.dart.compiler.DartCompilationPhase;
 import com.google.dart.compiler.DartCompilerContext;
@@ skipping 41 matching lines @@
 import com.google.dart.compiler.ast.DartSwitchMember;
 import com.google.dart.compiler.ast.DartSwitchStatement;
 import com.google.dart.compiler.ast.DartThisExpression;
 import com.google.dart.compiler.ast.DartTryStatement;
 import com.google.dart.compiler.ast.DartTypeNode;
 import com.google.dart.compiler.ast.DartTypedLiteral;
 import com.google.dart.compiler.ast.DartUnit;
 import com.google.dart.compiler.ast.DartUnqualifiedInvocation;
 import com.google.dart.compiler.ast.DartVariable;
 import com.google.dart.compiler.ast.DartVariableStatement;
+import com.google.dart.compiler.ast.DartVisitor;
 import com.google.dart.compiler.ast.DartWhileStatement;
 import com.google.dart.compiler.ast.Modifiers;
 import com.google.dart.compiler.type.FunctionType;
 import com.google.dart.compiler.type.InterfaceType;
 import com.google.dart.compiler.type.InterfaceType.Member;
 import com.google.dart.compiler.type.Type;
 import com.google.dart.compiler.type.TypeVariable;
 
 import java.util.EnumSet;
 import java.util.Iterator;
@@ skipping 259 matching lines @@
 
       if (Elements.isNonFactoryConstructor(member)) {
         resolveInitializers(node);
       }
 
       context = previousContext;
       innermostFunction = currentMethod = null;
       return member;
     }
 
-    private void resolveConstantExpression(DartExpression defaultExpr) {
-      resolve(defaultExpr);
-      checkConstantExpression(defaultExpr);
+    private void resolveConstantExpression(DartExpression expr) {
+      resolve(expr);
+      checkConstantExpression(expr);
     }
 
-    private void checkConstantExpression(DartExpression defaultExpr) {
-      // See bug 4568007.
-    }
-
-    private void checkConstantLiteral(DartExpression defaultExpr) {
-      if ((!(defaultExpr instanceof DartLiteral))
-          || ((defaultExpr instanceof DartTypedLiteral)
-              && (!((DartTypedLiteral) defaultExpr).isConst()))) {
-        resolutionError(defaultExpr, DartCompilerErrorCode.EXPECTED_CONSTANT_LITERAL);
+    private void checkConstantExpression(DartExpression expr) {
+      if (expr != null) {
+        DartVisitor v = CompileTimeConstVisitor.create(typeProvider, context);
+        v.accept(expr);
       }
     }
 
+    private void checkConstantLiteral(DartExpression expr) {
+      boolean isConstant = true;
+      if (expr instanceof DartStringInterpolation) {
+        isConstant = false;
+      } else if (expr instanceof DartLiteral) {
+        if (expr instanceof DartTypedLiteral && !((DartTypedLiteral) expr).isConst()){
+          isConstant = false;
+        }
+      } else {
+        isConstant = false;
+      }
+
+      if (!isConstant) {
+        resolutionError(expr, DartCompilerErrorCode.EXPECTED_CONSTANT_LITERAL);
+      }
+    }
+
     @Override
     public Element visitField(DartField node) {
       DartExpression expression = node.getValue();
       Modifiers modifiers = node.getModifiers();
       boolean isStatic = modifiers.isStatic();
       boolean isFinal = modifiers.isFinal();
       boolean isTopLevel = ElementKind.of(currentHolder).equals(ElementKind.LIBRARY);
 
       if (expression != null) {
+        resolve(expression);
         if (isStatic || isTopLevel) {
           checkConstantExpression(expression);
+          // Now, this constant has a type. Save it for future reference
+          Element element = node.getSymbol();
+          if (expression.getType() != null) {
+            Elements.setType(element, expression.getType());
+          }
         } else {
           // TODO(5200401): Only allow constant literals for inline field initializers for now.
           checkConstantLiteral(expression);

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

Could you remove that TODO now? We should be able to call a const constructor
and the constant check visitor will validate it, right?

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

I wasn't sure that non static variables needed to have compile time constant
initializers.  Sounds too strict?

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

Right now, non-static variables can only have compile-time constants as
initializers. Otherwise we would have execution of code that is not in a
constructor's body. That's what we want to avoid.

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

I agree. This should be a checkConstantExpression.

         }
-        resolve(expression);
       } else if (isStatic && isFinal) {
         resolutionError(node, DartCompilerErrorCode.STATIC_FINAL_REQUIRES_VALUE);
       }
 
-      // If field is an acessor, both getter and setter need to be visited (if present).
+      // If field is an accessor, both getter and setter need to be visited (if present).
       FieldElement field = node.getSymbol();
       if (field.getGetter() != null) {
         resolve(field.getGetter().getNode());
       }
       if (field.getSetter() != null) {
         resolve(field.getSetter().getNode());
       }
       return null;
     }
 
@@ skipping 458 matching lines @@
 
     @Override
     public Element visitFunctionObjectInvocation(DartFunctionObjectInvocation x) {
       x.getTarget().accept(this);
       visit(x.getArgs());
       return null;
     }
 
     @Override
     public Element visitNewExpression(DartNewExpression x) {
+
       this.visit(x.getArgs());
 
+      if (x.isConst()) {
+        for (DartExpression arg : x.getArgs()) {
+         checkConstantExpression(arg);
+        }
+      }
+
       Element element = x.getConstructor().accept(getContext().new Selector() {
         // Only 'new' expressions can have a type in a property access.
         @Override public Element visitTypeNode(DartTypeNode type) {
           return recordType(type, resolveType(type, inStaticContext(currentMethod)));
         }
 
         @Override public Element visitPropertyAccess(DartPropertyAccess node) {
           Element element = node.getQualifier().accept(this);
           if (ElementKind.of(element).equals(ElementKind.CLASS)) {
             return Elements.lookupConstructor(((ClassElement) element), node.getPropertyName());
@@ skipping 348 matching lines @@
           && ElementKind.of(target).equals(ElementKind.METHOD)) {
         if (!target.getModifiers().isStatic() && !Elements.isTopLevel(target)) {
           resolutionError(node, DartCompilerErrorCode.INSTANCE_METHOD_FROM_STATIC);
         }
       }
     }
 
     private void checkVariableStatement(DartVariableStatement node,
                                         DartVariable variable,
                                         boolean isImplicitlyInitialized) {
-      if (node.getModifiers().isFinal()) {
+      Modifiers modifiers = node.getModifiers();
+      if (modifiers.isFinal()) {
         if (!isImplicitlyInitialized && (variable.getValue() == null)) {
           resolutionError(variable.getName(), DartCompilerErrorCode.CONSTANTS_MUST_BE_INITIALIZED);
         } else if (isImplicitlyInitialized && (variable.getValue() != null)) {
           resolutionError(variable.getName(), DartCompilerErrorCode.CANNOT_BE_INITIALIZED);
-        } else {
-          checkConstantExpression(variable.getValue());
+        } else if (modifiers.isConstant() && variable.getValue() != null) {
+          resolveConstantExpression(variable.getValue());
+          node.setType(variable.getValue().getType());
         }
       }
     }
 
     private void checkParameterInitializer(DartMethodDefinition method, DartParameter parameter) {
       if (Elements.isNonFactoryConstructor(method.getSymbol())) {
         if (method.getModifiers().isRedirectedConstructor()) {
           resolutionError(parameter.getName(),
               DartCompilerErrorCode.PARAMETER_INIT_WITH_REDIR_CONSTRUCTOR);
         }
@@ skipping 100 matching lines @@
         ClassElement nextClass = (ClassElement) nextConstructorElement.getEnclosingElement();
         ClassElement currentClass = (ClassElement) constructor.getEnclosingElement();
         if (nextClass.getName().equals(currentClass.getName())) {
           return nextConstructorElement;
         }
       }
     }
     return null;
   }
 }