Merge commit '65401da92251a7318e3264b816ce0c4e14701751' into analyzer

Author: stereotype441

CHANGELOG.md

@@ -25,15 +25,21 @@
 
 #### Linter
 
-The linter was bumped to `0.1.73` which introduces the following new lints to the SDK:
+The linter was bumped to `0.1.75` which introduces the following new lints to the SDK:
 
 * `unnecessary_await_in_return`
 * `use_function_type_syntax_for_parameters`
 * `avoid_returning_null_for_future`
 * `avoid_shadowing_type_parameters`
 
+and:
+
+* `unnecessary_parenthesis` lint has been improved to handle function expressions.
+
 In addition, `prefer_bool_in_asserts` has been deprecated as its semantics are
-redundant with Dart 2 checks.
+redundant with Dart 2 checks and experimental lints `avoid_positional_boolean_parameters`,
+`literal_only_boolean_expressions`, `prefer_foreach`, `prefer_void_to_null` have all been
+promoted to stable.
 
 #### Other Tools
 

DEPS

@@ -97,7 +97,7 @@ vars = {
   "intl_tag": "0.15.7",
   "jinja2_rev": "2222b31554f03e62600cd7e383376a7c187967a1",
   "json_rpc_2_tag": "2.0.9",
-  "linter_tag": "0.1.73",
+  "linter_tag": "0.1.75",
   "logging_tag": "0.11.3+2",
   "markdown_tag": "2.0.2",
   "matcher_tag": "0.12.3",

pkg/analyzer/lib/error/error.dart

@@ -413,6 +413,7 @@ const List<ErrorCode> errorCodeValues = const [
   ParserErrorCode.FACTORY_WITHOUT_BODY,
   ParserErrorCode.FACTORY_WITH_INITIALIZERS,
   ParserErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR,
+  ParserErrorCode.FIELD_INITIALIZED_OUTSIDE_DECLARING_CLASS,
   ParserErrorCode.FINAL_AND_COVARIANT,
   ParserErrorCode.FINAL_AND_VAR,
   ParserErrorCode.FINAL_CLASS,

pkg/analyzer/lib/src/dart/error/syntactic_errors.dart

@@ -256,6 +256,9 @@ class ParserErrorCode extends ErrorCode {
   static const ParserErrorCode FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR =
       _FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR;
 
+  static const ParserErrorCode FIELD_INITIALIZED_OUTSIDE_DECLARING_CLASS =
+      _FIELD_INITIALIZED_OUTSIDE_DECLARING_CLASS;
+
   static const ParserErrorCode FINAL_AND_COVARIANT = _FINAL_AND_COVARIANT;
 
   static const ParserErrorCode FINAL_AND_VAR = _FINAL_AND_VAR;

pkg/analyzer/lib/src/dart/error/syntactic_errors.g.dart

@@ -95,6 +95,7 @@ final fastaAnalyzerErrorCodes = <ErrorCode>[
   _EXTERNAL_FACTORY_REDIRECTION,
   _EXTERNAL_FACTORY_WITH_BODY,
   _EXTERNAL_CONSTRUCTOR_WITH_BODY,
+  _FIELD_INITIALIZED_OUTSIDE_DECLARING_CLASS,
 ];
 
 const ParserErrorCode _ABSTRACT_CLASS_MEMBER = const ParserErrorCode(
@@ -301,6 +302,12 @@ const ParserErrorCode _FACTORY_TOP_LEVEL_DECLARATION = const ParserErrorCode(
     r"Top-level declarations can't be declared to be 'factory'.",
     correction: "Try removing the keyword 'factory'.");
 
+const ParserErrorCode _FIELD_INITIALIZED_OUTSIDE_DECLARING_CLASS =
+    const ParserErrorCode('FIELD_INITIALIZED_OUTSIDE_DECLARING_CLASS',
+        r"A field can only be initialized in it's declaring class",
+        correction:
+            "Try moving the field initialization into the constructor body.");
+
 const ParserErrorCode _FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR =
     const ParserErrorCode('FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR',
         r"Field formal parameters can only be used in a constructor.",

pkg/analyzer/lib/src/fasta/ast_builder.dart

@@ -625,12 +625,23 @@ class AstBuilder extends StackListener {
         SimpleIdentifier fieldName;
         Expression left = initializerObject.leftHandSide;
         if (left is PropertyAccess) {
-          var thisExpression = left.target as ThisExpression;
-          thisKeyword = thisExpression.thisKeyword;
-          period = left.operator;
+          Expression target = left.target;
+          if (target is ThisExpression) {
+            thisKeyword = target.thisKeyword;
+            period = left.operator;
+          } else {
+            assert(target is SuperExpression);
+            // Recovery:
+            // Parser has reported FieldInitializedOutsideDeclaringClass.
+          }
           fieldName = left.propertyName;
+        } else if (left is SimpleIdentifier) {
+          fieldName = left;
         } else {
-          fieldName = left as SimpleIdentifier;
+          // Recovery:
+          // Parser has reported invalid assignment.
+          SuperExpression superExpression = left;
+          fieldName = ast.simpleIdentifier(superExpression.superKeyword);
         }
         initializers.add(ast.constructorFieldInitializer(
             thisKeyword,

pkg/analyzer/test/generated/parser_test.dart

@@ -3890,6 +3890,41 @@ class Wrong<T> {
     ]);
   }
 
+  void test_invalidConstructorSuperAssignment() {
+    createParser("C() : super = 42;");
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(usingFastaParser
+        ? [expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 6, 5)]
+        : [
+            expectedError(ParserErrorCode.EXPECTED_TOKEN, 14, 1),
+            expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 16, 2),
+            expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 16, 2),
+            expectedError(
+                ParserErrorCode.REDIRECTION_IN_NON_FACTORY_CONSTRUCTOR, 16, 0),
+          ]);
+  }
+
+  void test_invalidConstructorSuperFieldAssignment() {
+    createParser("C() : super.a = 42;");
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(usingFastaParser
+        ? [
+            expectedError(
+                ParserErrorCode.FIELD_INITIALIZED_OUTSIDE_DECLARING_CLASS,
+                12,
+                1)
+          ]
+        : [
+            expectedError(ParserErrorCode.EXPECTED_TOKEN, 14, 1),
+            expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 16, 2),
+            expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 16, 2),
+            expectedError(
+                ParserErrorCode.REDIRECTION_IN_NON_FACTORY_CONSTRUCTOR, 16, 0),
+          ]);
+  }
+
   void test_invalidHexEscape_invalidDigit() {
     StringLiteral literal = parseExpression("'not \\x0 a'",
         errors: [expectedError(ParserErrorCode.INVALID_HEX_ESCAPE, 5, 3)]);

pkg/compiler/lib/src/commandline_options.dart

@@ -74,6 +74,7 @@ class Flags {
 
   static const String readData = '--read-data';
   static const String writeData = '--write-data';
+  static const String cfeOnly = '--cfe-only';
 
   static const String serverMode = '--server-mode';
 

pkg/compiler/lib/src/compiler.dart

@@ -168,8 +168,8 @@ abstract class Compiler {
     enqueuer = backend.makeEnqueuer();
 
     tasks = [
-      kernelLoader =
-          new KernelLoaderTask(options, provider, reporter, measurer),
+      kernelLoader = new KernelLoaderTask(
+          options, provider, _outputProvider, reporter, measurer),
       kernelFrontEndTask,
       globalInference = new GlobalTypeInferenceTask(this),
       constants = backend.constantCompilerTask,
@@ -255,6 +255,7 @@ abstract class Compiler {
       if (compilationFailed && !options.generateCodeWithCompileTimeErrors) {
         return;
       }
+      if (options.cfeOnly) return;
       _mainLibraryUri = result.rootLibraryUri;
 
       frontendStrategy.registerLoadedLibraries(result);

pkg/compiler/lib/src/dart2js.dart

@@ -263,6 +263,10 @@ Future<api.CompilationResult> compile(List<String> argv,
     compilationStrategy = CompilationStrategy.fromData;
   }
 
+  void setCfeOnly(String argument) {
+    compilationStrategy = CompilationStrategy.toKernel;
+  }
+
   void setWriteData(String argument) {
     if (compilationStrategy == CompilationStrategy.fromData) {
       fail("Cannot read and write serialized simultaneously.");
@@ -333,6 +337,7 @@ Future<api.CompilationResult> compile(List<String> argv,
     new OptionHandler('--libraries-spec=.+', setLibrarySpecificationUri),
     new OptionHandler('${Flags.readData}|${Flags.readData}=.+', setReadData),
     new OptionHandler('${Flags.writeData}|${Flags.writeData}=.+', setWriteData),
+    new OptionHandler(Flags.cfeOnly, setCfeOnly),
     new OptionHandler('--out=.+|-o.*', setOutput, multipleArguments: true),
     new OptionHandler('-O.*', setOptimizationLevel),
     new OptionHandler(Flags.allowMockCompilation, ignoreOption),
@@ -492,6 +497,10 @@ Future<api.CompilationResult> compile(List<String> argv,
     case CompilationStrategy.direct:
       out ??= currentDirectory.resolve('out.js');
       break;
+    case CompilationStrategy.toKernel:
+      out ??= currentDirectory.resolve('out.dill');
+      options.add(Flags.cfeOnly);
+      break;
     case CompilationStrategy.toData:
       out ??= currentDirectory.resolve('out.dill');
       writeDataUri ??= currentDirectory.resolve('$out.data');
@@ -544,6 +553,18 @@ Future<api.CompilationResult> compile(List<String> argv,
           }
         }
         break;
+      case CompilationStrategy.toKernel:
+        int dartCharactersRead = inputProvider.dartCharactersRead;
+        int dataBytesWritten = outputProvider.totalDataWritten;
+        print('Compiled '
+            '${_formatCharacterCount(dartCharactersRead)} characters Dart to '
+            '${_formatCharacterCount(dataBytesWritten)} kernel bytes in '
+            '${_formatDurationAsSeconds(wallclock.elapsed)} seconds');
+        String input = uriPathToNative(scriptName);
+        String dillOutput =
+            relativize(currentDirectory, out, Platform.isWindows);
+        print('Dart file ($input) compiled to ${dillOutput}.');
+        break;
       case CompilationStrategy.toData:
         int dartCharactersRead = inputProvider.dartCharactersRead;
         int dataBytesWritten = outputProvider.totalDataWritten;
@@ -1007,4 +1028,4 @@ void batchMain(List<String> batchArguments) {
   });
 }
 
-enum CompilationStrategy { direct, toData, fromData }
+enum CompilationStrategy { direct, toKernel, toData, fromData }

pkg/compiler/lib/src/kernel/loader.dart

@@ -9,6 +9,7 @@ import 'dart:async';
 import 'package:front_end/src/fasta/kernel/utils.dart';
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/binary/ast_from_binary.dart' show BinaryBuilder;
+import 'package:kernel/binary/ast_to_binary.dart' show BinaryPrinter;
 
 import 'package:front_end/src/api_unstable/dart2js.dart' as fe;
 import 'package:kernel/kernel.dart' hide LibraryDependency, Combinator;
@@ -18,6 +19,7 @@ import '../../compiler_new.dart' as api;
 import '../common/tasks.dart' show CompilerTask, Measurer;
 import '../common.dart';
 import '../options.dart';
+import '../util/sink_adapter.dart';
 
 import 'front_end_adapter.dart';
 import 'dart2js_target.dart' show Dart2jsTarget;
@@ -31,6 +33,7 @@ class KernelLoaderTask extends CompilerTask {
   final DiagnosticReporter _reporter;
 
   final api.CompilerInput _compilerInput;
+  final api.CompilerOutput _compilerOutput;
 
   final CompilerOptions _options;
 
@@ -43,8 +46,8 @@ class KernelLoaderTask extends CompilerTask {
   /// This is used for testing.
   bool forceSerialization = false;
 
-  KernelLoaderTask(
-      this._options, this._compilerInput, this._reporter, Measurer measurer)
+  KernelLoaderTask(this._options, this._compilerInput, this._compilerOutput,
+      this._reporter, Measurer measurer)
       : initializedCompilerState = _options.kernelInitializedCompilerState,
         super(measurer);
 
@@ -78,6 +81,20 @@ class KernelLoaderTask extends CompilerTask {
             resolvedUri);
       }
       if (component == null) return null;
+
+      if (_options.cfeOnly) {
+        measureSubtask('serialize dill', () {
+          _reporter.log('Writing dill to ${_options.outputUri}');
+          api.BinaryOutputSink dillOutput =
+              _compilerOutput.createBinarySink(_options.outputUri);
+          BinaryOutputSinkAdapter irSink =
+              new BinaryOutputSinkAdapter(dillOutput);
+          BinaryPrinter printer = new BinaryPrinter(irSink);
+          printer.writeComponentFile(component);
+          irSink.close();
+        });
+      }
+
       if (forceSerialization) {
         // TODO(johnniwinther): Remove this when #34942 is fixed.
         List<int> data = serializeComponent(component);

pkg/compiler/lib/src/options.dart

@@ -62,6 +62,10 @@ class CompilerOptions implements DiagnosticOptions {
   /// If this is set, the compilation stops after type inference.
   Uri writeDataUri;
 
+  /// Whether to run only the CFE and emit the generated kernel file in
+  /// [outputUri].
+  bool cfeOnly = false;
+
   /// Resolved constant "environment" values passed to the compiler via the `-D`
   /// flags.
   Map<String, String> environment = const <String, String>{};
@@ -332,7 +336,8 @@ class CompilerOptions implements DiagnosticOptions {
       ..verbose = _hasOption(options, Flags.verbose)
       ..showInternalProgress = _hasOption(options, Flags.progress)
       ..readDataUri = _extractUriOption(options, '${Flags.readData}=')
-      ..writeDataUri = _extractUriOption(options, '${Flags.writeData}=');
+      ..writeDataUri = _extractUriOption(options, '${Flags.writeData}=')
+      ..cfeOnly = _hasOption(options, Flags.cfeOnly);
   }
 
   void validate() {

pkg/compiler/lib/src/serialization/strategies.dart

@@ -10,14 +10,14 @@ import 'package:front_end/src/fasta/kernel/utils.dart';
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/binary/ast_from_binary.dart' show BinaryBuilder;
 
-import '../../compiler_new.dart' as api;
 import '../diagnostics/diagnostic_listener.dart';
 import '../environment.dart';
 import '../js_model/js_world.dart';
 import '../options.dart';
 import '../source_file_provider.dart';
 import '../types/abstract_value_domain.dart';
 import '../types/types.dart';
+import '../util/sink_adapter.dart';
 import 'serialization.dart';
 import 'task.dart';
 
@@ -130,19 +130,3 @@ class ObjectsInMemorySerializationStrategy
         abstractValueStrategy, component, source);
   }
 }
-
-class BinaryOutputSinkAdapter implements Sink<List<int>> {
-  api.BinaryOutputSink output;
-
-  BinaryOutputSinkAdapter(this.output);
-
-  @override
-  void add(List<int> data) {
-    output.write(data);
-  }
-
-  @override
-  void close() {
-    output.close();
-  }
-}

pkg/compiler/lib/src/serialization/task.dart

@@ -16,7 +16,7 @@ import '../js_model/js_world.dart';
 import '../options.dart';
 import '../types/abstract_value_domain.dart';
 import '../types/types.dart';
-import 'strategies.dart';
+import '../util/sink_adapter.dart';
 import 'serialization.dart';
 
 void serializeGlobalTypeInferenceResults(
@@ -53,6 +53,9 @@ class SerializationTask extends CompilerTask {
 
   void serialize(GlobalTypeInferenceResults results) {
     measureSubtask('serialize dill', () {
+      // TODO(sigmund): remove entirely: we will do this immediately as soon as
+      // we get the component in the kernel/loader.dart task once we refactor
+      // how we apply our modular kernel transformation for super mixin calls.
       compiler.reporter.log('Writing dill to ${compiler.options.outputUri}');
       api.BinaryOutputSink dillOutput =
           compiler.outputProvider.createBinarySink(compiler.options.outputUri);

pkg/compiler/lib/src/util/sink_adapter.dart

@@ -0,0 +1,17 @@
+import '../../compiler_new.dart' as api;
+
+class BinaryOutputSinkAdapter implements Sink<List<int>> {
+  api.BinaryOutputSink output;
+
+  BinaryOutputSinkAdapter(this.output);
+
+  @override
+  void add(List<int> data) {
+    output.write(data);
+  }
+
+  @override
+  void close() {
+    output.close();
+  }
+}