More co19 triage.

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

 // Copyright (c) 2012, 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.collect.Maps;
 import com.google.common.collect.Sets;
 import com.google.dart.compiler.DartCompilationError;
 import com.google.dart.compiler.DartCompilationPhase;
@@ skipping 34 matching lines @@
 import com.google.dart.compiler.ast.DartUnaryExpression;
 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.Modifiers;
 import com.google.dart.compiler.common.HasSourceInfo;
 import com.google.dart.compiler.type.Type;
 import com.google.dart.compiler.type.TypeKind;
 
+import java.math.BigInteger;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 /**
  * Given an tree, finds all compile-time constant expressions, and determines if
  * each expression matches all the rules for a compile-time constant. Emits a
  * resolution error if not.
  *
  * This script doesn't just resolve expressions, it also sets types to the
@@ skipping 105 matching lines @@
      * @return a non <code>null</code> type value. Dynamic if none other can be
      * determined.
      */
     private Type getMostSpecificType(DartNode node) {
       if (node != null) {
         Type type = inferredTypes.get(node);
         if (type != null) {
           return type;
         }
         Element element = node.getElement();
+        if (Elements.isFunctionIdentical(element)) {
+          return boolType;
+        }
         if (element != null) {
           type = element.getType();
           if (type != null && TypeKind.of(type) != TypeKind.DYNAMIC) {
             return type;
           }
           if (element instanceof VariableElement) {
             VariableElement variable = (VariableElement) element;
             if (variable.getModifiers().isConstant()) {
               DartExpression value = variable.getDefaultValue();
               if (value != null) {
@@ skipping 77 matching lines @@
             }
           } else {
             checkMathExpression(x, lhs, rhs, lhsType, rhsType);
           }
           break;
         case SUB:
         case MUL:
         case DIV:
           checkMathExpression(x, lhs, rhs, lhsType, rhsType);
           break;
+        case TRUNC:
+          reportExceptionIfZeroLiteral(x, rhs);
+          // pass-through
         case MOD:
-        case TRUNC:
           if (checkNumber(lhs, lhsType) && checkNumber(rhs, rhsType)) {
             rememberInferredType(x, intType);
           }
           break;
         case LT:
         case GT:
         case LTE:
         case GTE:
           if (checkNumber(lhs, lhsType) && checkNumber(rhs, rhsType)) {
             rememberInferredType(x, boolType);
           }
           break;
 
         default:
           // all other operators...
           expectedConstant(x);
       }
       return null;
     }
+    
+    private void reportExceptionIfZeroLiteral(HasSourceInfo target, DartExpression e) {
+      if (e instanceof DartIntegerLiteral) {
+        DartIntegerLiteral literal = (DartIntegerLiteral) e;
+        if (literal.getValue().equals(BigInteger.ZERO)) {
+          context.onError(new DartCompilationError(target,
+              ResolverErrorCode.CONSTANTS_EVALUATION_EXCEPTION));
+        }
+      }
+    }
 
     private void checkMathExpression(DartBinaryExpression x,
                                      DartExpression lhs, DartExpression rhs,
                                      Type lhsType, Type rhsType) {
       if (checkNumber(lhs, lhsType) && checkNumber(rhs, rhsType)) {
         if (lhsType.equals(intType) && rhsType.equals(intType)) {
           rememberInferredType(x, intType);
         } else if (lhsType.equals(doubleType) && rhsType.equals(doubleType)) {
           rememberInferredType(x, doubleType);
         } else  if (lhsType.equals(doubleType) && rhsType.equals(intType)
@@ skipping 483 matching lines @@
       expression.accept(visitor);
       return visitor.getMostSpecificType(expression);
     }
     return null;
   }
 
   public void exec(DartUnit unit) {
     unit.accept(new FindCompileTimeConstantExpressionsVisitor());
   }
 }