Create a class for evaluating const instance creation expressions.

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, 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.
 
 library engine.resolver;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/utilities_collection.dart';
@@ skipping 806 matching lines @@
    * The error reporter by which errors will be reported.
    */
   final ErrorReporter _errorReporter;
 
   /**
    * The type provider used to access the known types.
    */
   final TypeProvider _typeProvider;
 
   /**
+   * The set of variables declared using '-D' on the command line.
+   */
+  final DeclaredVariables declaredVariables;
+
+  /**
    * The type representing the type 'bool'.
    */
   InterfaceType _boolType;
 
   /**
    * The type representing the type 'int'.
    */
   InterfaceType _intType;
 
   /**
    * The type representing the type 'num'.
    */
   InterfaceType _numType;
 
   /**
    * The type representing the type 'string'.
    */
   InterfaceType _stringType;
 
   /**
    * The current library that is being analyzed.
    */
   final LibraryElement _currentLibrary;
 
   /**
    * Initialize a newly created constant verifier.
    *
    * @param errorReporter the error reporter by which errors will be reported
    */
-  ConstantVerifier(
-      this._errorReporter, this._currentLibrary, this._typeProvider) {
+  ConstantVerifier(this._errorReporter, this._currentLibrary,
+      this._typeProvider, this.declaredVariables) {
     this._boolType = _typeProvider.boolType;
     this._intType = _typeProvider.intType;
     this._numType = _typeProvider.numType;
     this._stringType = _typeProvider.stringType;
   }
 
   @override
   Object visitAnnotation(Annotation node) {
     super.visitAnnotation(node);
     // check annotation creation
@@ skipping 100 matching lines @@
                 CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS,
                 key, [type.displayName]);
           }
         }
       } else {
         // Note: we throw the errors away because this isn't actually a const.
         AnalysisErrorListener errorListener =
             AnalysisErrorListener.NULL_LISTENER;
         ErrorReporter subErrorReporter =
             new ErrorReporter(errorListener, _errorReporter.source);
-        DartObjectImpl result =
-            key.accept(new ConstantVisitor(_typeProvider, subErrorReporter));
+        DartObjectImpl result = key.accept(new ConstantVisitor(
+            new ConstantEvaluationEngine(_typeProvider, declaredVariables),
+            subErrorReporter));
         if (result != null) {
           if (keys.contains(result)) {
             invalidKeys.add(key);
           } else {
             keys.add(result);
           }
         } else {
           reportEqualKeys = false;
         }
       }
@@ skipping 182 matching lines @@
    * time constant, or `null` if the expression is not a compile time constant.
    *
    * @param expression the expression to be validated
    * @param errorCode the error code to be used if the expression is not a compile time constant
    * @return the value of the compile time constant
    */
   DartObjectImpl _validate(Expression expression, ErrorCode errorCode) {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     ErrorReporter subErrorReporter =
         new ErrorReporter(errorListener, _errorReporter.source);
-    DartObjectImpl result =
-        expression.accept(new ConstantVisitor(_typeProvider, subErrorReporter));
+    DartObjectImpl result = expression.accept(new ConstantVisitor(
+        new ConstantEvaluationEngine(_typeProvider, declaredVariables),
+        subErrorReporter));
     _reportErrors(errorListener.errors, errorCode);
     return result;
   }
 
   /**
    * Validate that if the passed arguments are constant expressions.
    *
    * @param argumentList the argument list to evaluate
    */
   void _validateConstantArguments(ArgumentList argumentList) {
@@ skipping 85 matching lines @@
           for (VariableDeclaration variableDeclaration
               in fieldDeclaration.fields.variables) {
             Expression initializer = variableDeclaration.initializer;
             if (initializer != null) {
               // Ignore any errors produced during validation--if the constant
               // can't be eavluated we'll just report a single error.
               AnalysisErrorListener errorListener =
                   AnalysisErrorListener.NULL_LISTENER;
               ErrorReporter subErrorReporter =
                   new ErrorReporter(errorListener, _errorReporter.source);
-              DartObjectImpl result = initializer
-                  .accept(new ConstantVisitor(_typeProvider, subErrorReporter));
+              DartObjectImpl result = initializer.accept(new ConstantVisitor(
+                  new ConstantEvaluationEngine(
+                      _typeProvider, declaredVariables), subErrorReporter));
               if (result == null) {
                 _errorReporter.reportErrorForNode(
                     CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_FIELD_INITIALIZED_BY_NON_CONST,
                     errorSite, [variableDeclaration.name.name]);
               }
             }
           }
         }
       }
     }
   }
 
   /**
    * Validates that the given expression is a compile time constant.
    *
    * @param parameterElements the elements of parameters of constant constructor, they are
    *          considered as a valid potentially constant expressions
    * @param expression the expression to validate
    */
   void _validateInitializerExpression(
       List<ParameterElement> parameterElements, Expression expression) {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     ErrorReporter subErrorReporter =
         new ErrorReporter(errorListener, _errorReporter.source);
     DartObjectImpl result = expression.accept(
-        new _ConstantVerifier_validateInitializerExpression(
-            _typeProvider, subErrorReporter, this, parameterElements));
+        new _ConstantVerifier_validateInitializerExpression(_typeProvider,
+            subErrorReporter, this, parameterElements, declaredVariables));
     _reportErrors(errorListener.errors,
         CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER);
     if (result != null) {
       _reportErrorIfFromDeferredLibrary(expression,
           CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY);
     }
   }
 
   /**
    * Validates that all of the arguments of a constructor initializer are compile time constants.
@@ skipping 7136 matching lines @@
       computer.computeValues();
       // As a temporary workaround for issue 21572, run ConstantVerifier now.
       // TODO(paulberry): remove this workaround once issue 21572 is fixed.
       for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
           try {
             CompilationUnit unit = library.getAST(source);
             ErrorReporter errorReporter =
                 new ErrorReporter(_errorListener, source);
             ConstantVerifier constantVerifier = new ConstantVerifier(
-                errorReporter, library.libraryElement, _typeProvider);
+                errorReporter, library.libraryElement, _typeProvider,
+                analysisContext.declaredVariables);
             unit.accept(constantVerifier);
           } on AnalysisException catch (exception, stackTrace) {
             AnalysisEngine.instance.logger.logError(
                 "Internal Error: Could not access AST for ${source.fullName} "
                 "during constant verification",
                 new CaughtException(exception, stackTrace));
           }
         }
       }
     });
@@ skipping 503 matching lines @@
       computer.computeValues();
       // As a temporary workaround for issue 21572, run ConstantVerifier now.
       // TODO(paulberry): remove this workaround once issue 21572 is fixed.
       for (ResolvableLibrary library in _librariesInCycle) {
         for (ResolvableCompilationUnit unit
             in library.resolvableCompilationUnits) {
           CompilationUnit ast = unit.compilationUnit;
           ErrorReporter errorReporter =
               new ErrorReporter(_errorListener, unit.source);
           ConstantVerifier constantVerifier = new ConstantVerifier(
-              errorReporter, library.libraryElement, _typeProvider);
+              errorReporter, library.libraryElement, _typeProvider,
+              analysisContext.declaredVariables);
           ast.accept(constantVerifier);
         }
       }
     });
   }
 
   /**
    * Resolve the identifiers and perform type analysis in the libraries in the current cycle.
    *
    * @throws AnalysisException if any of the identifiers could not be resolved or if any of the
@@ skipping 6258 matching lines @@
     }
     return null;
   }
 }
 
 class _ConstantVerifier_validateInitializerExpression extends ConstantVisitor {
   final ConstantVerifier verifier;
 
   List<ParameterElement> parameterElements;
 
-  _ConstantVerifier_validateInitializerExpression(TypeProvider arg0,
-      ErrorReporter arg1, this.verifier, this.parameterElements)
-      : super(arg0, arg1);
+  _ConstantVerifier_validateInitializerExpression(TypeProvider typeProvider,
+      ErrorReporter errorReporter, this.verifier, this.parameterElements,
+      DeclaredVariables declaredVariables)
+      : super(new ConstantEvaluationEngine(typeProvider, declaredVariables),
+          errorReporter);
 
   @override
   DartObjectImpl visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     for (ParameterElement parameterElement in parameterElements) {
       if (identical(parameterElement, element) && parameterElement != null) {
         DartType type = parameterElement.type;
         if (type != null) {
           if (type.isDynamic) {
             return new DartObjectImpl(
@@ skipping 136 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }