Add support for assert statements with messages to the analyzer.

pkg/analyzer/lib/src/generated/engine.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;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:math' as math;
 
@@ skipping 1115 matching lines @@
   void set analysisOptions(AnalysisOptions options) {
     bool needsRecompute = this._options.analyzeFunctionBodiesPredicate !=
             options.analyzeFunctionBodiesPredicate ||
         this._options.generateImplicitErrors !=
             options.generateImplicitErrors ||
         this._options.generateSdkErrors != options.generateSdkErrors ||
         this._options.dart2jsHint != options.dart2jsHint ||
         (this._options.hint && !options.hint) ||
         this._options.preserveComments != options.preserveComments ||
         this._options.strongMode != options.strongMode ||
+        this._options.enableAssertMessage != options.enableAssertMessage ||
         this._options.enableStrictCallChecks !=
             options.enableStrictCallChecks ||
         this._options.enableSuperMixins != options.enableSuperMixins;
     int cacheSize = options.cacheSize;
     if (this._options.cacheSize != cacheSize) {
       this._options.cacheSize = cacheSize;
       //cache.setMaxCacheSize(cacheSize);
       _privatePartition.maxCacheSize = cacheSize;
       //
       // Cap the size of the priority list to being less than the cache size.
       // Failure to do so can result in an infinite loop in
       // performAnalysisTask() because re-caching one AST structure
       // can cause another priority source's AST structure to be flushed.
       //
       // TODO(brianwilkerson) Remove this constraint when the new task model is
       // implemented.
       //
       int maxPriorityOrderSize = cacheSize - _PRIORITY_ORDER_SIZE_DELTA;
       if (_priorityOrder.length > maxPriorityOrderSize) {
         _priorityOrder = _priorityOrder.sublist(0, maxPriorityOrderSize);
       }
     }
     this._options.analyzeFunctionBodiesPredicate =
         options.analyzeFunctionBodiesPredicate;
     this._options.generateImplicitErrors = options.generateImplicitErrors;
     this._options.generateSdkErrors = options.generateSdkErrors;
     this._options.dart2jsHint = options.dart2jsHint;
+    this._options.enableAssertMessage = options.enableAssertMessage;
     this._options.enableStrictCallChecks = options.enableStrictCallChecks;
     this._options.enableSuperMixins = options.enableSuperMixins;
     this._options.hint = options.hint;
     this._options.incremental = options.incremental;
     this._options.incrementalApi = options.incrementalApi;
     this._options.incrementalValidation = options.incrementalValidation;
     this._options.lint = options.lint;
     this._options.preserveComments = options.preserveComments;
     this._options.strongMode = options.strongMode;
     _generateImplicitErrors = options.generateImplicitErrors;
@@ skipping 5022 matching lines @@
    * kept in the cache.
    */
   int get cacheSize;
 
   /**
    * Return `true` if analysis is to generate dart2js related hint results.
    */
   bool get dart2jsHint;
 
   /**
+   * Return `true` to enable custom assert messages (DEP 37).
+   */
+  bool get enableAssertMessage;
+
+  /**
    * Return `true` if analysis is to include the new async support.
    */
   @deprecated // Always true
   bool get enableAsync;
 
   /**
    * Return `true` if analysis is to include the new deferred loading support.
    */
   @deprecated // Always true
   bool get enableDeferredLoading;
@@ skipping 113 matching lines @@
    */
   int cacheSize = DEFAULT_CACHE_SIZE;
 
   /**
    * A flag indicating whether analysis is to generate dart2js related hint
    * results.
    */
   bool dart2jsHint = false;
 
   /**
+   * A flag indicating whether custom assert messages are to be supported (DEP
+   * 37).
+   */
+  bool enableAssertMessage = false;
+
+  /**
    * A flag indicating whether generic methods are to be supported (DEP 22).
    */
   bool enableGenericMethods = false;
 
   /**
    * A flag indicating whether analysis is to strictly follow the specification
    * when generating warnings on "call" methods (fixes dartbug.com/21938).
    */
   bool enableStrictCallChecks = false;
 
@@ skipping 61 matching lines @@
 
   /**
    * Initialize a newly created set of analysis options to have the same values
    * as those in the given set of analysis [options].
    */
   @deprecated // Use new AnalysisOptionsImpl.from(options)
   AnalysisOptionsImpl.con1(AnalysisOptions options) {
     analyzeFunctionBodiesPredicate = options.analyzeFunctionBodiesPredicate;
     cacheSize = options.cacheSize;
     dart2jsHint = options.dart2jsHint;
+    enableAssertMessage = options.enableAssertMessage;
     enableStrictCallChecks = options.enableStrictCallChecks;
     enableSuperMixins = options.enableSuperMixins;
     generateImplicitErrors = options.generateImplicitErrors;
     generateSdkErrors = options.generateSdkErrors;
     hint = options.hint;
     incremental = options.incremental;
     incrementalApi = options.incrementalApi;
     incrementalValidation = options.incrementalValidation;
     lint = options.lint;
     preserveComments = options.preserveComments;
     strongMode = options.strongMode;
   }
 
   /**
    * Initialize a newly created set of analysis options to have the same values
    * as those in the given set of analysis [options].
    */
   AnalysisOptionsImpl.from(AnalysisOptions options) {
     analyzeFunctionBodiesPredicate = options.analyzeFunctionBodiesPredicate;
     cacheSize = options.cacheSize;
     dart2jsHint = options.dart2jsHint;
+    enableAssertMessage = options.enableAssertMessage;
     enableStrictCallChecks = options.enableStrictCallChecks;
     enableSuperMixins = options.enableSuperMixins;
     generateImplicitErrors = options.generateImplicitErrors;
     generateSdkErrors = options.generateSdkErrors;
     hint = options.hint;
     incremental = options.incremental;
     incrementalApi = options.incrementalApi;
     incrementalValidation = options.incrementalValidation;
     lint = options.lint;
     preserveComments = options.preserveComments;
@@ skipping 2038 matching lines @@
 //      ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, libraryElement, typeProvider);
 //      _unit.accept(constantVerifier);
       //
       // Use the ErrorVerifier to compute the rest of the errors.
       //
       ErrorVerifier errorVerifier = new ErrorVerifier(
           errorReporter,
           libraryElement,
           typeProvider,
           new InheritanceManager(libraryElement),
-          context.analysisOptions.enableSuperMixins);
+          context.analysisOptions.enableSuperMixins,
+          context.analysisOptions.enableAssertMessage);
       _unit.accept(errorVerifier);
       _errors = errorListener.getErrorsForSource(source);
     });
   }
 
   /**
    * Check each directive in the given compilation unit to see if the referenced source exists and
    * report an error if it does not.
    *
    * @param context the context in which the library exists
@@ skipping 2431 matching lines @@
     //
     // Perform additional error checking.
     //
     PerformanceStatistics.errors.makeCurrentWhile(() {
       ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
       ErrorVerifier errorVerifier = new ErrorVerifier(
           errorReporter,
           _libraryElement,
           typeProvider,
           inheritanceManager,
-          context.analysisOptions.enableSuperMixins);
+          context.analysisOptions.enableSuperMixins,
+          context.analysisOptions.enableAssertMessage);
       unit.accept(errorVerifier);
       // TODO(paulberry): as a temporary workaround for issue 21572,
       // ConstantVerifier is being run right after ConstantValueComputer, so we
       // don't need to run it here.  Once issue 21572 is fixed, re-enable the
       // call to ConstantVerifier.
 //       ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, _libraryElement, typeProvider);
 //       unit.accept(constantVerifier);
     });
     //
     // Capture the results.
@@ skipping 1073 matching lines @@
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, source, computeValue);
     if (!pendingFuture.evaluate(sourceEntry)) {
       _context._pendingFutureSources
           .putIfAbsent(source, () => <PendingFuture>[])
           .add(pendingFuture);
     }
     return pendingFuture.future;
   }
 }