Add FileState.hasMixin/hasMixinLibrary properties.

pkg/front_end/lib/src/incremental/file_state.dart

 // Copyright (c) 2017, 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.
 
 import 'dart:async';
 import 'dart:typed_data';
 
 import 'package:crypto/crypto.dart';
 import 'package:front_end/file_system.dart';
 import 'package:front_end/src/base/api_signature.dart';
@@ skipping 26 matching lines @@
 
   /// The absolute URI of the file.
   final Uri uri;
 
   /// The resolved URI of the file in the file system.
   final Uri fileUri;
 
   bool _exists;
   List<int> _content;
   List<int> _contentHash;
+  bool _hasMixin;
   List<int> _apiSignature;
 
   List<NamespaceExport> _exports;
   List<FileState> _importedLibraries;
   List<FileState> _exportedLibraries;
   List<FileState> _partFiles;
 
   Set<FileState> _directReferencedFiles = new Set<FileState>();
   List<FileState> _directReferencedLibraries = <FileState>[];
 
@@ skipping 21 matching lines @@
 
   /// The list of the libraries exported by this library.
   List<FileState> get exportedLibraries => _exportedLibraries;
 
   /// The list of the exported files with combinators.
   List<NamespaceExport> get exports => _exports;
 
   @override
   int get hashCode => uri.hashCode;
 
+  /// Whether the file has a mixin application.
+  bool get hasMixin => _hasMixin;

[ahe, 2017/06/12 19:22:03]

Rename to hasMixinApplication? I think it's important to keep that distinction.

[scheglov, 2017/06/12 19:43:18]

Yeah, I actually named it initially this way.
But it felt too long.

You're right, hasMixinApplication is more precise.
Done.

+
+  /// Whether a unit of the library has a mixin application.
+  bool get hasMixinLibrary {

[ahe, 2017/06/12 19:22:03]

hasMixinApplicationLibrary?

But how about this: rename the above method to "hasMixinApplicationInPart" and
this to "hasMixinApplication".

+    return _hasMixin || _partFiles.any((part) => part._hasMixin);
+  }
+
   /// The list of the libraries imported by this library.
   List<FileState> get importedLibraries => _importedLibraries;
 
   /// The list of files this library file references as parts.
   List<FileState> get partFiles => _partFiles;
 
   /// Return topologically sorted cycles of dependencies for this library.
   List<LibraryCycle> get topologicalOrder {
     var libraryWalker = new _LibraryWalker();
     libraryWalker.walk(libraryWalker.getNode(this));
@@ skipping 33 matching lines @@
       _content = new Uint8List(0);
       _exists = false;
     }
 
     // Compute the content hash.
     _contentHash = md5.convert(_content).bytes;
 
     // Scan the content.
     ScannerResult scanResult = _scan();
 
-    // Compute the API signature.
-    _apiSignature = _computeApiSignature(scanResult.tokens);
+    // Compute syntactic properties.
+    _computeSyntacticProperties(scanResult.tokens);
 
     // Parse directives.
     var listener = new _DirectiveListenerWithNative();
     new TopLevelParser(listener).parseUnit(scanResult.tokens);
 
     // Build the graph.
     _importedLibraries = <FileState>[];
     _exportedLibraries = <FileState>[];
     _partFiles = <FileState>[];
     _exports = <NamespaceExport>[];
@@ skipping 50 matching lines @@
     if (uri.toString() != 'dart:core') return;
     for (String uri in new VmTarget(null).extraRequiredLibraries) {
       FileState file = await _getFileForRelativeUri(uri);
       // TODO(scheglov) add error handling
       if (file != null) {
         _importedLibraries.add(file);
       }
     }
   }
 
-  /// Compute and return the API signature of the file.
+  /// Compute syntactic properties of the file: [_apiSignature] and [_hasMixin].
   ///
   /// The signature is based on non-comment tokens of the file outside
   /// of function bodies.
-  List<int> _computeApiSignature(Token token) {
+  void _computeSyntacticProperties(Token token) {
     var parser = new _BodySkippingParser();
     parser.parseUnit(token);
 
+    _hasMixin = parser.hasMixin;
+
     ApiSignature apiSignature = new ApiSignature();
     apiSignature.addBytes(_fsState._salt);
 
     // Iterate over tokens and skip bodies.
     Iterator<_BodyRange> bodyIterator = parser.bodyRanges.iterator;
     bodyIterator.moveNext();
     for (; token.kind != EOF_TOKEN; token = token.next) {
       // Move to the body range that ends after the token.
       while (bodyIterator.current != null &&
           bodyIterator.current.last < token.charOffset) {
         bodyIterator.moveNext();
       }
       // If the current body range starts before or at the token, skip it.
       if (bodyIterator.current != null &&
           bodyIterator.current.first <= token.charOffset) {
         continue;
       }
       // The token is outside of a function body, add it.
       apiSignature.addString(token.lexeme);
     }
 
-    return apiSignature.toByteList();
+    // Store the API signature.
+    _apiSignature = apiSignature.toByteList();
   }
 
   /// Exclude all `native 'xyz';` token sequences.
   void _excludeNativeClauses(Token token) {
     for (; token.kind != EOF_TOKEN; token = token.next) {
       if (optional('native', token) &&
           token.next.kind == STRING_TOKEN &&
           optional(';', token.next.next)) {
         token.previous.next = token.next.next;
       }
@@ skipping 179 matching lines @@
   final int last;
 
   _BodyRange(this.first, this.last);
 
   @override
   String toString() => '[$first, $last]';
 }
 
 /// The [Parser] that skips function bodies and remembers their token ranges.
 class _BodySkippingParser extends Parser {
+  bool hasMixin = false;
   final List<_BodyRange> bodyRanges = [];
 
   _BodySkippingParser() : super(new Listener());
 
   @override
   Token parseFunctionBody(Token token, bool isExpression, bool allowAbstract) {
     if (identical('{', token.lexeme)) {
       Token close = skipBlock(token);
       bodyRanges.add(new _BodyRange(token.charOffset, close.charOffset));
       return close;
     }
     return super.parseFunctionBody(token, isExpression, allowAbstract);
   }
+
+  Token parseMixinApplication(Token token) {
+    hasMixin = true;
+    return super.parseMixinApplication(token);
+  }
 }
 
 /// [DirectiveListener] that skips native clauses.
 class _DirectiveListenerWithNative extends DirectiveListener {
   @override
   Token handleNativeClause(Token token) => skipNativeClause(token);
 }
 
 /// [FileSystemState] based implementation of [FileSystem].
 /// It provides a consistent view on the known file system state.
@@ skipping 78 matching lines @@
       node.isEvaluated = true;
       cycle.libraries.add(node.file);
     }
     topologicallySortedCycles.add(cycle);
   }
 
   _LibraryNode getNode(FileState file) {
     return nodesOfFiles.putIfAbsent(file, () => new _LibraryNode(this, file));
   }
 }