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 16 matching lines @@
 import com.google.dart.compiler.ast.DartFunctionExpression;
 import com.google.dart.compiler.ast.DartFunctionObjectInvocation;
 import com.google.dart.compiler.ast.DartFunctionTypeAlias;
 import com.google.dart.compiler.ast.DartGotoStatement;
 import com.google.dart.compiler.ast.DartIdentifier;
 import com.google.dart.compiler.ast.DartIfStatement;
 import com.google.dart.compiler.ast.DartInitializer;
 import com.google.dart.compiler.ast.DartIntegerLiteral;
 import com.google.dart.compiler.ast.DartInvocation;
 import com.google.dart.compiler.ast.DartLabel;
-import com.google.dart.compiler.ast.DartLiteral;
 import com.google.dart.compiler.ast.DartMapLiteral;
 import com.google.dart.compiler.ast.DartMethodDefinition;
 import com.google.dart.compiler.ast.DartMethodInvocation;
 import com.google.dart.compiler.ast.DartNamedExpression;
 import com.google.dart.compiler.ast.DartNewExpression;
 import com.google.dart.compiler.ast.DartNode;
+import com.google.dart.compiler.ast.DartNodeTraverser;
 import com.google.dart.compiler.ast.DartParameter;
 import com.google.dart.compiler.ast.DartPropertyAccess;
 import com.google.dart.compiler.ast.DartRedirectConstructorInvocation;
 import com.google.dart.compiler.ast.DartStatement;
 import com.google.dart.compiler.ast.DartStringInterpolation;
 import com.google.dart.compiler.ast.DartStringLiteral;
 import com.google.dart.compiler.ast.DartSuperConstructorInvocation;
 import com.google.dart.compiler.ast.DartSuperExpression;
 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.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;
@@ skipping 263 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) {
+        DartNodeTraverser<Void> v = CompileTimeConstVisitor.create(typeProvider, context);
+        expr.accept(v);
       }
     }
 
     @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 (isTopLevel && isFinal) {
+        modifiers.makeStatic();
+      }
+
       if (expression != null) {
-        if (isStatic || isTopLevel) {
-          checkConstantExpression(expression);
-        } else {
-          // TODO(5200401): Only allow constant literals for inline field initializers for now.
-          checkConstantLiteral(expression);
+        resolve(expression);
+        checkConstantExpression(expression);
+        // Now, this constant has a type. Save it for future reference

[floitsch, 2011/10/14 22:46:15]

end sentence with dot.

+        Element element = node.getSymbol();
+        if (expression.getType() != null) {
+          Elements.setType(element, expression.getType());
         }
-        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.isStatic() && modifiers.isFinal() && 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;
   }
 }