Implement the new '??' operator in 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine;
 
 import "dart:math" as math;
@@ skipping 1025 matching lines @@
   @override
   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.enableNullAwareOperators !=
+            options.enableNullAwareOperators ||
         this._options.enableStrictCallChecks != options.enableStrictCallChecks;
     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.enableNullAwareOperators = options.enableNullAwareOperators;
     this._options.enableStrictCallChecks = options.enableStrictCallChecks;
     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;
     _generateImplicitErrors = options.generateImplicitErrors;
     _generateSdkErrors = options.generateSdkErrors;
     if (needsRecompute) {
@@ skipping 3575 matching lines @@
       // prepare the existing unit
       CompilationUnit oldUnit =
           getResolvedCompilationUnit2(unitSource, librarySource);
       if (oldUnit == null) {
         return false;
       }
       // do resolution
       Stopwatch perfCounter = new Stopwatch()..start();
       PoorMansIncrementalResolver resolver = new PoorMansIncrementalResolver(
           typeProvider, unitSource, dartEntry, oldUnit,
-          analysisOptions.incrementalApi);
+          analysisOptions.incrementalApi, analysisOptions);
       bool success = resolver.resolve(newCode);
       AnalysisEngine.instance.instrumentationService.logPerformance(
           AnalysisPerformanceKind.INCREMENTAL, perfCounter,
           'success=$success,context_id=$_id,code_length=${newCode.length}');
       if (!success) {
         return false;
       }
       // if validation, remember the result, but throw it away
       if (analysisOptions.incrementalValidation) {
         incrementalResolutionValidation_lastUnitSource = oldUnit.element.source;
@@ skipping 1310 matching lines @@
   @deprecated // Always true
   bool get enableDeferredLoading;
 
   /**
    * Return `true` if analysis is to include the new enum support.
    */
   @deprecated // Always true
   bool get enableEnum;
 
   /**
+   * Return `true` to enable null-aware operators (DEP 9).
+   */
+  bool get enableNullAwareOperators;
+
+  /**
    * Return `true` to strictly follow the specification when generating
    * warnings on "call" methods (fixes dartbug.com/21938).
    */
   bool get enableStrictCallChecks;
 
   /**
    * Return `true` if errors, warnings and hints should be generated for sources
    * that are implicitly being analyzed. The default value is `true`.
    */
   bool get generateImplicitErrors;
@@ skipping 73 matching lines @@
    */
   int cacheSize = DEFAULT_CACHE_SIZE;
 
   /**
    * A flag indicating whether analysis is to generate dart2js related hint
    * results.
    */
   bool dart2jsHint = true;
 
   /**
+   * A flag indicating whether null-aware operators should be parsed (DEP 9).
+   */
+  bool enableNullAwareOperators = 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;
 
   /**
    * A flag indicating whether errors, warnings and hints should be generated
    * for sources that are implicitly being analyzed.
    */
   bool generateImplicitErrors = true;
@@ skipping 44 matching lines @@
   AnalysisOptionsImpl();
 
   /**
    * Initialize a newly created set of analysis options to have the same values
    * as those in the given set of analysis [options].
    */
   AnalysisOptionsImpl.con1(AnalysisOptions options) {
     analyzeFunctionBodiesPredicate = options.analyzeFunctionBodiesPredicate;
     cacheSize = options.cacheSize;
     dart2jsHint = options.dart2jsHint;
+    enableNullAwareOperators = options.enableNullAwareOperators;
     enableStrictCallChecks = options.enableStrictCallChecks;
     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 2783 matching lines @@
     if (cache == null) {
       return;
     }
     // Only handle small changes
     if (cache.oldLength > 0 || cache.newLength > 30) {
       return;
     }
     // Produce an updated token stream
     CharacterReader reader = new CharSequenceReader(cache.newContents);
     BooleanErrorListener errorListener = new BooleanErrorListener();
-    IncrementalScanner scanner =
-        new IncrementalScanner(cache.source, reader, errorListener);
+    IncrementalScanner scanner = new IncrementalScanner(
+        cache.source, reader, errorListener, context.analysisOptions);
     scanner.rescan(cache.resolvedUnit.beginToken, cache.offset, cache.oldLength,
         cache.newLength);
     if (errorListener.errorReported) {
       return;
     }
     // Produce an updated AST
     IncrementalParser parser = new IncrementalParser(
         cache.source, scanner.tokenMap, AnalysisErrorListener.NULL_LISTENER);
     _updatedUnit = parser.reparse(cache.resolvedUnit, scanner.leftToken,
         scanner.rightToken, cache.offset, cache.offset + cache.oldLength);
@@ skipping 572 matching lines @@
   accept(AnalysisTaskVisitor visitor) => visitor.visitParseHtmlTask(this);
 
   @override
   void internalPerform() {
     try {
       ht.AbstractScanner scanner = new ht.StringScanner(source, _content);
       scanner.passThroughElements = <String>[_TAG_SCRIPT];
       ht.Token token = scanner.tokenize();
       _lineInfo = new LineInfo(scanner.lineStarts);
       RecordingErrorListener errorListener = new RecordingErrorListener();
-      _unit = new ht.HtmlParser(source, errorListener).parse(token, _lineInfo);
+      _unit = new ht.HtmlParser(source, errorListener, context.analysisOptions)
+          .parse(token, _lineInfo);
       _unit.accept(new RecursiveXmlVisitor_ParseHtmlTask_internalPerform(
           this, errorListener));
       _errors = errorListener.getErrorsForSource(source);
       _referencedLibraries = librarySources;
     } catch (exception, stackTrace) {
       throw new AnalysisException(
           "Exception", new CaughtException(exception, stackTrace));
     }
   }
 
@@ skipping 1212 matching lines @@
   accept(AnalysisTaskVisitor visitor) => visitor.visitScanDartTask(this);
 
   @override
   void internalPerform() {
     PerformanceStatistics.scan.makeCurrentWhile(() {
       RecordingErrorListener errorListener = new RecordingErrorListener();
       try {
         Scanner scanner = new Scanner(
             source, new CharSequenceReader(_content), errorListener);
         scanner.preserveComments = context.analysisOptions.preserveComments;
+        scanner.enableNullAwareOperators =
+            context.analysisOptions.enableNullAwareOperators;
         _tokenStream = scanner.tokenize();
         _lineInfo = new LineInfo(scanner.lineStarts);
         _errors = errorListener.getErrorsForSource(source);
       } catch (exception, stackTrace) {
         throw new AnalysisException(
             "Exception", new CaughtException(exception, stackTrace));
       }
     });
   }
 }
@@ skipping 849 matching lines @@
   visitElement(Element element) {
     if (element.id == _id) {
       result = element;
       throw new _ElementByIdFinderException();
     }
     super.visitElement(element);
   }
 }
 
 class _ElementByIdFinderException {}