| // Copyright (c) 2020, 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' show Future, StreamSubscription; |
| |
| import 'dart:convert' show JsonEncoder, jsonDecode, utf8; |
| |
| import 'dart:io' show BytesBuilder, File, stdin, stdout; |
| import 'dart:math' show max; |
| |
| import 'dart:typed_data' show Uint8List; |
| |
| import 'package:_fe_analyzer_shared/src/parser/parser.dart' show Parser; |
| |
| import 'package:_fe_analyzer_shared/src/scanner/scanner.dart' |
| show ErrorToken, ScannerConfiguration, Token; |
| |
| import 'package:_fe_analyzer_shared/src/scanner/token.dart' show Token; |
| |
| import 'package:dev_compiler/src/kernel/target.dart' show DevCompilerTarget; |
| |
| import 'package:front_end/src/api_prototype/compiler_options.dart' |
| show CompilerOptions, DiagnosticMessage; |
| |
| import 'package:front_end/src/api_prototype/experimental_flags.dart' |
| show ExperimentalFlag; |
| |
| import 'package:front_end/src/api_prototype/file_system.dart' |
| show FileSystem, FileSystemEntity, FileSystemException; |
| |
| import 'package:front_end/src/base/processed_options.dart' |
| show ProcessedOptions; |
| |
| import 'package:front_end/src/fasta/compiler_context.dart' show CompilerContext; |
| |
| import 'package:front_end/src/fasta/incremental_compiler.dart' |
| show IncrementalCompiler; |
| |
| import 'package:front_end/src/fasta/kernel/utils.dart' show ByteSink; |
| import 'package:front_end/src/fasta/util/direct_parser_ast.dart'; |
| import 'package:front_end/src/fasta/util/direct_parser_ast_helper.dart'; |
| |
| import 'package:front_end/src/fasta/util/textual_outline.dart' |
| show textualOutline; |
| |
| import 'package:kernel/ast.dart' show Component; |
| |
| import 'package:kernel/binary/ast_to_binary.dart' show BinaryPrinter; |
| |
| import 'package:kernel/target/targets.dart' show Target, TargetFlags; |
| import 'package:package_config/package_config.dart'; |
| |
| import "package:vm/target/flutter.dart" show FlutterTarget; |
| |
| import "package:vm/target/vm.dart" show VmTarget; |
| |
| import 'incremental_load_from_dill_suite.dart' show getOptions; |
| |
| import 'parser_test_listener.dart' show ParserTestListener; |
| |
| import 'parser_suite.dart' as parser_suite; |
| |
| final FakeFileSystem fs = new FakeFileSystem(); |
| Uri mainUri; |
| Uri platformUri; |
| bool noPlatform = false; |
| bool nnbd = false; |
| bool experimentalInvalidation = false; |
| bool serialize = false; |
| bool widgetTransformation = false; |
| List<Uri> invalidate = []; |
| String targetString = "VM"; |
| String expectedCrashLine; |
| bool oldBlockDelete = false; |
| bool lineDelete = false; |
| bool byteDelete = false; |
| bool askAboutRedirectCrashTarget = false; |
| int stackTraceMatches = 1; |
| Set<String> askedAboutRedirect = {}; |
| bool _quit = false; |
| bool skip = false; |
| |
| Future<bool> shouldQuit() async { |
| // allow some time for stdin.listen to process data. |
| await new Future.delayed(new Duration(milliseconds: 5)); |
| return _quit; |
| } |
| |
| // TODO(jensj): Option to automatically find and search for _all_ crashes that |
| // it uncovers --- i.e. it currently has an option to ask if we want to search |
| // for the other crash instead --- add an option so it does that automatically |
| // for everything it sees. One can possibly just make a copy of the state of |
| // the file system and save that for later... |
| |
| main(List<String> arguments) async { |
| String filename; |
| Uri loadFsJson; |
| for (String arg in arguments) { |
| if (arg.startsWith("--")) { |
| if (arg == "--nnbd") { |
| nnbd = true; |
| } else if (arg == "--experimental-invalidation") { |
| experimentalInvalidation = true; |
| } else if (arg == "--serialize") { |
| serialize = true; |
| } else if (arg.startsWith("--fsJson=")) { |
| String jsJson = arg.substring("--fsJson=".length); |
| loadFsJson = Uri.base.resolve(jsJson); |
| } else if (arg.startsWith("--platform=")) { |
| String platform = arg.substring("--platform=".length); |
| platformUri = Uri.base.resolve(platform); |
| } else if (arg == "--no-platform") { |
| noPlatform = true; |
| } else if (arg.startsWith("--invalidate=")) { |
| for (String s in arg.substring("--invalidate=".length).split(",")) { |
| invalidate.add(Uri.base.resolve(s)); |
| } |
| } else if (arg.startsWith("--widgetTransformation")) { |
| widgetTransformation = true; |
| } else if (arg.startsWith("--target=VM")) { |
| targetString = "VM"; |
| } else if (arg.startsWith("--target=flutter")) { |
| targetString = "flutter"; |
| } else if (arg.startsWith("--target=ddc")) { |
| targetString = "ddc"; |
| } else if (arg == "--oldBlockDelete") { |
| oldBlockDelete = true; |
| } else if (arg == "--lineDelete") { |
| lineDelete = true; |
| } else if (arg == "--byteDelete") { |
| byteDelete = true; |
| } else if (arg == "--ask-redirect-target") { |
| askAboutRedirectCrashTarget = true; |
| } else if (arg.startsWith("--stack-matches=")) { |
| String stackMatches = arg.substring("--stack-matches=".length); |
| stackTraceMatches = int.parse(stackMatches); |
| } else { |
| throw "Unknown option $arg"; |
| } |
| } else if (filename != null) { |
| throw "Already got '$filename', '$arg' is also a filename; " |
| "can only get one"; |
| } else { |
| filename = arg; |
| } |
| } |
| if (noPlatform) { |
| int i = 0; |
| while (platformUri == null || new File.fromUri(platformUri).existsSync()) { |
| platformUri = Uri.base.resolve("nonexisting_$i"); |
| i++; |
| } |
| } else { |
| if (platformUri == null) { |
| throw "No platform given. Use --platform=/path/to/platform.dill"; |
| } |
| if (!new File.fromUri(platformUri).existsSync()) { |
| throw "The platform file '$platformUri' doesn't exist"; |
| } |
| } |
| if (filename == null) { |
| throw "Need file to operate on"; |
| } |
| File file = new File(filename); |
| if (!file.existsSync()) throw "File $filename doesn't exist."; |
| mainUri = file.absolute.uri; |
| |
| try { |
| await tryToMinimize(loadFsJson); |
| } catch (e) { |
| print("\n\n\nABOUT TO CRASH. DUMPING FS."); |
| dumpFsToJson(); |
| print("\n\n\nABOUT TO CRASH. FS DUMPED."); |
| rethrow; |
| } |
| } |
| |
| Future tryToMinimize(Uri loadFsJson) async { |
| // Set main to be basically empty up front. |
| fs.data[mainUri] = utf8.encode("main() {}"); |
| Component initialComponent = await getInitialComponent(); |
| print("Compiled initially (without data)"); |
| // Remove fake cache. |
| fs.data.remove(mainUri); |
| |
| if (loadFsJson != null) { |
| File f = new File.fromUri(loadFsJson); |
| fs.initializeFromJson((jsonDecode(f.readAsStringSync()))); |
| } |
| |
| // First assure it actually crash on the input. |
| if (!await crashesOnCompile(initialComponent)) { |
| throw "Input doesn't crash the compiler."; |
| } |
| print("Step #1: We did crash on the input!"); |
| |
| // All file should now be cached. |
| fs._redirectAndRecord = false; |
| |
| try { |
| stdin.echoMode = false; |
| stdin.lineMode = false; |
| } catch (e) { |
| print("error setting settings on stdin"); |
| } |
| StreamSubscription<List<int>> stdinSubscription = |
| stdin.listen((List<int> event) { |
| if (event.length == 1 && event.single == "q".codeUnits.single) { |
| print("\n\nGot told to quit!\n\n"); |
| _quit = true; |
| } else if (event.length == 1 && event.single == "s".codeUnits.single) { |
| print("\n\nGot told to skip!\n\n"); |
| skip = true; |
| } else if (event.length == 1 && event.single == "i".codeUnits.single) { |
| print("\n\n--- STATUS INFORMATION START ---\n\n"); |
| int totalFiles = 0; |
| int emptyFiles = 0; |
| int combinedSize = 0; |
| for (Uri uri in fs.data.keys) { |
| final Uint8List originalBytes = fs.data[uri]; |
| if (originalBytes == null) continue; |
| totalFiles++; |
| if (originalBytes.isEmpty) emptyFiles++; |
| combinedSize += originalBytes.length; |
| } |
| print("Total files left: $totalFiles."); |
| print("Of which empty: $emptyFiles."); |
| print("Combined size left: $combinedSize bytes."); |
| print("\n\n--- STATUS INFORMATION END ---\n\n"); |
| skip = true; |
| } else { |
| print("\n\nGot stdin input: $event\n\n"); |
| } |
| }); |
| |
| // For all dart files: Parse them as set their source as the parsed source |
| // to "get around" any encoding issues when printing later. |
| Map<Uri, Uint8List> copy = new Map.from(fs.data); |
| for (Uri uri in fs.data.keys) { |
| if (await shouldQuit()) break; |
| String uriString = uri.toString(); |
| if (uriString.endsWith(".json") || |
| uriString.endsWith(".packages") || |
| uriString.endsWith(".dill") || |
| fs.data[uri] == null || |
| fs.data[uri].isEmpty) { |
| // skip |
| } else { |
| try { |
| String parsedString = getFileAsStringContent(fs.data[uri], nnbd); |
| fs.data[uri] = utf8.encode(parsedString); |
| } catch (e) { |
| // crash in scanner/parser --- keep original file. This crash might |
| // be what we're looking for! |
| } |
| } |
| } |
| if (!await crashesOnCompile(initialComponent)) { |
| // Now - for whatever reason - we didn't crash. Restore. |
| fs.data.clear(); |
| fs.data.addAll(copy); |
| } |
| |
| // Operate on one file at a time: Try to delete all content in file. |
| List<Uri> uris = new List<Uri>.from(fs.data.keys); |
| |
| // TODO(jensj): Can we "thread" this? |
| bool changedSome = true; |
| while (changedSome) { |
| if (await shouldQuit()) break; |
| while (changedSome) { |
| if (await shouldQuit()) break; |
| changedSome = false; |
| for (int i = 0; i < uris.length; i++) { |
| if (await shouldQuit()) break; |
| Uri uri = uris[i]; |
| if (fs.data[uri] == null || fs.data[uri].isEmpty) continue; |
| print("About to work on file $i of ${uris.length}"); |
| await deleteContent(uris, i, false, initialComponent); |
| if (fs.data[uri] == null || fs.data[uri].isEmpty) changedSome = true; |
| } |
| } |
| |
| // Try to delete empty files. |
| bool changedSome2 = true; |
| while (changedSome2) { |
| if (await shouldQuit()) break; |
| changedSome2 = false; |
| for (int i = 0; i < uris.length; i++) { |
| if (await shouldQuit()) break; |
| Uri uri = uris[i]; |
| if (fs.data[uri] == null || fs.data[uri].isNotEmpty) continue; |
| print("About to work on file $i of ${uris.length}"); |
| await deleteContent(uris, i, false, initialComponent, deleteFile: true); |
| if (fs.data[uri] == null) { |
| changedSome = true; |
| changedSome2 = true; |
| } |
| } |
| } |
| |
| int left = 0; |
| for (Uri uri in uris) { |
| if (fs.data[uri] == null || fs.data[uri].isEmpty) continue; |
| left++; |
| } |
| print("There's now $left files of ${fs.data.length} files left"); |
| |
| // Operate on one file at a time. |
| for (Uri uri in fs.data.keys) { |
| if (await shouldQuit()) break; |
| if (fs.data[uri] == null || fs.data[uri].isEmpty) continue; |
| |
| print("Now working on $uri"); |
| |
| int prevLength = fs.data[uri].length; |
| |
| await deleteBlocks(uri, initialComponent); |
| await deleteEmptyLines(uri, initialComponent); |
| |
| if (oldBlockDelete) { |
| // Try to delete blocks. |
| await deleteBlocksOld(uri, initialComponent); |
| } |
| |
| if (lineDelete) { |
| // Try to delete lines. |
| await deleteLines(uri, initialComponent); |
| } |
| |
| print("We're now at ${fs.data[uri].length} bytes for $uri " |
| "(was $prevLength)."); |
| if (prevLength != fs.data[uri].length) changedSome = true; |
| if (fs.data[uri].isEmpty) continue; |
| |
| if (byteDelete) { |
| // Now try to delete 'arbitrarily' (for any given start offset do an |
| // exponential binary search). |
| int prevLength = fs.data[uri].length; |
| while (true) { |
| if (await shouldQuit()) break; |
| await binarySearchDeleteData(uri, initialComponent); |
| |
| if (fs.data[uri].length == prevLength) { |
| // No progress. |
| break; |
| } else { |
| print("We're now at ${fs.data[uri].length} bytes"); |
| prevLength = fs.data[uri].length; |
| changedSome = true; |
| } |
| } |
| } |
| } |
| for (Uri uri in fs.data.keys) { |
| if (fs.data[uri] == null || fs.data[uri].isEmpty) continue; |
| if (await shouldQuit()) break; |
| if (await attemptInline(uri, initialComponent)) { |
| changedSome = true; |
| } |
| } |
| } |
| |
| if (await shouldQuit()) { |
| print("\n\nASKED TO QUIT\n\n"); |
| } else { |
| print("\n\nDONE\n\n"); |
| } |
| |
| Uri jsonFsOut = dumpFsToJson(); |
| |
| await stdinSubscription.cancel(); |
| |
| if (!await shouldQuit()) { |
| // Test converting to incremental compiler yaml test. |
| outputIncrementalCompilerYamlTest(); |
| print("\n\n\n"); |
| |
| for (Uri uri in uris) { |
| if (fs.data[uri] == null || fs.data[uri].isEmpty) continue; |
| print("Uri $uri has this content:"); |
| |
| try { |
| String utfDecoded = utf8.decode(fs.data[uri], allowMalformed: true); |
| print(utfDecoded); |
| } catch (e) { |
| print(fs.data[uri]); |
| print("(which crashes when trying to decode as utf8)"); |
| } |
| print("\n\n====================\n\n"); |
| } |
| |
| print("Wrote json file system to $jsonFsOut"); |
| } |
| } |
| |
| Uri dumpFsToJson() { |
| JsonEncoder jsonEncoder = new JsonEncoder.withIndent(" "); |
| String jsonFs = jsonEncoder.convert(fs); |
| int i = 0; |
| Uri jsonFsOut; |
| while (jsonFsOut == null || new File.fromUri(jsonFsOut).existsSync()) { |
| jsonFsOut = Uri.base.resolve("crash_minimizer_result_$i"); |
| i++; |
| } |
| new File.fromUri(jsonFsOut).writeAsStringSync(jsonFs); |
| print("Wrote json file system to $jsonFsOut"); |
| return jsonFsOut; |
| } |
| |
| /// Attempts to inline small files in other files. |
| /// Returns true if anything was changed, i.e. if at least one inlining was a |
| /// success. |
| Future<bool> attemptInline(Uri uri, Component initialComponent) async { |
| // Don't attempt to inline the main uri --- that's our entry! |
| if (uri == mainUri) return false; |
| |
| Uint8List inlineData = fs.data[uri]; |
| bool hasMultipleLines = false; |
| for (int i = 0; i < inlineData.length; i++) { |
| if (inlineData[i] == $LF) { |
| hasMultipleLines = true; |
| break; |
| } |
| } |
| // TODO(jensj): Maybe inline slightly bigger files too? |
| if (hasMultipleLines) { |
| return false; |
| } |
| |
| Uri inlinableUri = uri; |
| |
| int compileTry = 0; |
| bool changed = false; |
| |
| for (Uri uri in fs.data.keys) { |
| final Uint8List originalBytes = fs.data[uri]; |
| if (originalBytes == null || originalBytes.isEmpty) continue; |
| DirectParserASTContentCompilationUnitEnd ast = getAST(originalBytes, |
| includeBody: false, |
| includeComments: false, |
| enableExtensionMethods: true, |
| enableNonNullable: nnbd); |
| // Find all imports/exports of this file (if any). |
| // If finding any: |
| // * remove all of them, then |
| // * find the end of the last import/export, and |
| // * insert the content of the file there. |
| // * if that *doesn't* work and we've inserted an export, |
| // try converting that to an import instead. |
| List<Replacement> replacements = []; |
| for (DirectParserASTContentImportEnd import in ast.getImports()) { |
| Token importUriToken = import.importKeyword.next; |
| Uri importUri = _getUri(importUriToken, uri); |
| if (inlinableUri == importUri) { |
| replacements.add(new Replacement( |
| import.importKeyword.offset - 1, import.semicolon.offset + 1)); |
| } |
| } |
| for (DirectParserASTContentExportEnd export in ast.getExports()) { |
| Token exportUriToken = export.exportKeyword.next; |
| Uri exportUri = _getUri(exportUriToken, uri); |
| if (inlinableUri == exportUri) { |
| replacements.add(new Replacement( |
| export.exportKeyword.offset - 1, export.semicolon.offset + 1)); |
| } |
| } |
| if (replacements.isEmpty) continue; |
| |
| // Step 1: Remove all imports/exports of this file. |
| Uint8List candidate = _replaceRange(replacements, originalBytes); |
| |
| // Step 2: Find the last import/export. |
| int offsetOfLast = 0; |
| ast = getAST(candidate, |
| includeBody: false, |
| includeComments: false, |
| enableExtensionMethods: true, |
| enableNonNullable: nnbd); |
| for (DirectParserASTContentImportEnd import in ast.getImports()) { |
| offsetOfLast = max(offsetOfLast, import.semicolon.offset + 1); |
| } |
| for (DirectParserASTContentExportEnd export in ast.getExports()) { |
| offsetOfLast = max(offsetOfLast, export.semicolon.offset + 1); |
| } |
| |
| // Step 3: Insert the content of the file there. Note, though, |
| // that any imports/exports in _that_ file should be changed to be valid |
| // in regards to the new placement. |
| BytesBuilder builder = new BytesBuilder(); |
| for (int i = 0; i < offsetOfLast; i++) { |
| builder.addByte(candidate[i]); |
| } |
| builder.addByte($LF); |
| builder.add(_rewriteImportsExportsToUri(inlineData, uri, inlinableUri)); |
| builder.addByte($LF); |
| for (int i = offsetOfLast; i < candidate.length; i++) { |
| builder.addByte(candidate[i]); |
| } |
| candidate = builder.takeBytes(); |
| |
| // Step 4: Try it out. |
| if (await shouldQuit()) break; |
| if (skip) { |
| skip = false; |
| break; |
| } |
| stdout.write("."); |
| compileTry++; |
| if (compileTry % 50 == 0) { |
| stdout.write("(at $compileTry)\n"); |
| } |
| fs.data[uri] = candidate; |
| if (await crashesOnCompile(initialComponent)) { |
| print("Could inline $inlinableUri into $uri."); |
| changed = true; |
| // File was already updated. |
| } else { |
| // Couldn't replace that. |
| // Insert the original again. |
| fs.data[uri] = originalBytes; |
| |
| // If we've inlined an export, try changing that to an import. |
| builder = new BytesBuilder(); |
| for (int i = 0; i < offsetOfLast; i++) { |
| builder.addByte(candidate[i]); |
| } |
| // TODO(jensj): Only try compile again, if export was actually converted |
| // to import. |
| builder.addByte($LF); |
| builder.add(_rewriteImportsExportsToUri(inlineData, uri, inlinableUri, |
| convertExportToImport: true)); |
| builder.addByte($LF); |
| for (int i = offsetOfLast; i < candidate.length; i++) { |
| builder.addByte(candidate[i]); |
| } |
| candidate = builder.takeBytes(); |
| |
| // Step 4: Try it out. |
| if (await shouldQuit()) break; |
| if (skip) { |
| skip = false; |
| break; |
| } |
| stdout.write("."); |
| compileTry++; |
| if (compileTry % 50 == 0) { |
| stdout.write("(at $compileTry)\n"); |
| } |
| fs.data[uri] = candidate; |
| if (await crashesOnCompile(initialComponent)) { |
| print("Could inline $inlinableUri into $uri " |
| "(by converting export to import)."); |
| changed = true; |
| // File was already updated. |
| } else { |
| // Couldn't replace that. |
| // Insert the original again. |
| fs.data[uri] = originalBytes; |
| } |
| } |
| } |
| |
| return changed; |
| } |
| |
| Uint8List _rewriteImportsExportsToUri(Uint8List oldData, Uri newUri, Uri oldUri, |
| {bool convertExportToImport: false}) { |
| DirectParserASTContentCompilationUnitEnd ast = getAST(oldData, |
| includeBody: false, |
| includeComments: false, |
| enableExtensionMethods: true, |
| enableNonNullable: nnbd); |
| List<Replacement> replacements = []; |
| for (DirectParserASTContentImportEnd import in ast.getImports()) { |
| _rewriteImportsExportsToUriInternal( |
| import.importKeyword.next, oldUri, replacements, newUri); |
| } |
| for (DirectParserASTContentExportEnd export in ast.getExports()) { |
| if (convertExportToImport) { |
| replacements.add(new Replacement( |
| export.exportKeyword.offset - 1, |
| export.exportKeyword.offset + export.exportKeyword.length, |
| nullOrReplacement: utf8.encode('import'), |
| )); |
| } |
| _rewriteImportsExportsToUriInternal( |
| export.exportKeyword.next, oldUri, replacements, newUri); |
| } |
| if (replacements.isNotEmpty) { |
| Uint8List candidate = _replaceRange(replacements, oldData); |
| return candidate; |
| } |
| return oldData; |
| } |
| |
| void _rewriteImportsExportsToUriInternal( |
| Token uriToken, Uri oldUri, List<Replacement> replacements, Uri newUri) { |
| Uri tokenUri = _getUri(uriToken, oldUri, resolvePackage: false); |
| if (tokenUri.scheme == "package" || tokenUri.scheme == "dart") return; |
| Uri asPackageUri = _getImportUri(tokenUri); |
| if (asPackageUri.scheme == "package") { |
| // Just replace with this package uri. |
| replacements.add(new Replacement( |
| uriToken.offset - 1, |
| uriToken.offset + uriToken.length, |
| nullOrReplacement: utf8.encode('"${asPackageUri.toString()}"'), |
| )); |
| } else { |
| // TODO(jensj): Rewrite relative path to be correct. |
| throw "Rewrite $oldUri importing/exporting $tokenUri as $uriToken " |
| "for $newUri (notice $asPackageUri)"; |
| } |
| } |
| |
| Uri _getUri(Token uriToken, Uri uri, {bool resolvePackage: true}) { |
| String uriString = uriToken.lexeme; |
| uriString = uriString.substring(1, uriString.length - 1); |
| Uri uriTokenUri = uri.resolve(uriString); |
| if (resolvePackage && uriTokenUri.scheme == "package") { |
| Package package = _latestIncrementalCompiler |
| .currentPackagesMap[uriTokenUri.pathSegments.first]; |
| uriTokenUri = package.packageUriRoot |
| .resolve(uriTokenUri.pathSegments.skip(1).join("/")); |
| } |
| return uriTokenUri; |
| } |
| |
| Uri _getImportUri(Uri uri) { |
| return _latestIncrementalCompiler.userCode |
| .getEntryPointUri(uri, issueProblem: false); |
| } |
| |
| void outputIncrementalCompilerYamlTest() { |
| int dartFiles = 0; |
| for (MapEntry<Uri, Uint8List> entry in fs.data.entries) { |
| if (entry.key.pathSegments.last.endsWith(".dart")) { |
| if (entry.value != null) dartFiles++; |
| } |
| } |
| |
| print("------ Reproduction as semi-done incremental yaml test file ------"); |
| |
| // TODO(jensj): don't use full uris. |
| print(""" |
| # Copyright (c) 2020, 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.md file. |
| |
| # Reproduce a crash. |
| |
| type: newworld"""); |
| if (widgetTransformation) { |
| print("trackWidgetCreation: true"); |
| print("target: DDC # basically needed for widget creation to be run"); |
| } |
| print(""" |
| worlds: |
| - entry: $mainUri"""); |
| if (experimentalInvalidation) { |
| print(" experiments: alternative-invalidation-strategy"); |
| } |
| print(" sources:"); |
| for (MapEntry<Uri, Uint8List> entry in fs.data.entries) { |
| if (entry.value == null) continue; |
| print(" ${entry.key}: |"); |
| String string = utf8.decode(entry.value); |
| List<String> lines = string.split("\n"); |
| for (String line in lines) { |
| print(" $line"); |
| } |
| } |
| print(" expectedLibraryCount: $dartFiles " |
| "# with parts this is not right"); |
| print(""); |
| |
| for (Uri uri in invalidate) { |
| print(" - entry: $mainUri"); |
| if (experimentalInvalidation) { |
| print(" experiments: alternative-invalidation-strategy"); |
| } |
| print(" worldType: updated"); |
| print(" expectInitializeFromDill: false # or true?"); |
| print(" invalidate:"); |
| print(" - $uri"); |
| print(" expectedLibraryCount: $dartFiles " |
| "# with parts this is not right"); |
| print(" expectsRebuildBodiesOnly: true # or false?"); |
| print(""); |
| } |
| |
| print("------------------------------------------------------------------"); |
| } |
| |
| Uint8List sublist(Uint8List data, int start, int end) { |
| Uint8List result = new Uint8List(end - start); |
| result.setRange(0, result.length, data, start); |
| return result; |
| } |
| |
| String dataToText(Uint8List data) { |
| StringBuffer sb = new StringBuffer(); |
| String comma = "["; |
| for (int i = 0; i < data.length; i++) { |
| sb.write(comma); |
| sb.write(data[i]); |
| comma = ", "; |
| if (i > 100) break; |
| } |
| if (data.length > 100) { |
| sb.write("..."); |
| } |
| sb.write("]"); |
| return sb.toString(); |
| } |
| |
| void binarySearchDeleteData(Uri uri, Component initialComponent) async { |
| Uint8List latestCrashData = fs.data[uri]; |
| int offset = 0; |
| while (offset < latestCrashData.length) { |
| print("Working at offset $offset of ${latestCrashData.length}"); |
| BytesBuilder builder = new BytesBuilder(); |
| builder.add(sublist(latestCrashData, 0, offset)); |
| builder.add(sublist(latestCrashData, offset + 1, latestCrashData.length)); |
| Uint8List candidate = builder.takeBytes(); |
| fs.data[uri] = candidate; |
| if (!await crashesOnCompile(initialComponent)) { |
| // Deleting 1 char didn't crash; don't try to delete anymore starting |
| // here. |
| offset++; |
| continue; |
| } |
| |
| // Find how long we can go. |
| int crashingAt = 1; |
| int noLongerCrashingAt; |
| while (true) { |
| int deleteChars = 2 * crashingAt; |
| if (offset + deleteChars > latestCrashData.length) { |
| deleteChars = latestCrashData.length - offset; |
| } |
| builder = new BytesBuilder(); |
| builder.add(sublist(latestCrashData, 0, offset)); |
| builder.add(sublist( |
| latestCrashData, offset + deleteChars, latestCrashData.length)); |
| candidate = builder.takeBytes(); |
| fs.data[uri] = candidate; |
| if (!await crashesOnCompile(initialComponent)) { |
| noLongerCrashingAt = deleteChars; |
| break; |
| } |
| crashingAt = deleteChars; |
| if (crashingAt + offset == latestCrashData.length) break; |
| } |
| |
| if (noLongerCrashingAt == null) { |
| // We can delete the rest. |
| latestCrashData = candidate; |
| continue; |
| } |
| |
| // Binary search between [crashingAt] and [noLongerCrashingAt]. |
| while (crashingAt < noLongerCrashingAt) { |
| int mid = noLongerCrashingAt - |
| ((noLongerCrashingAt - crashingAt) >> 1); // Get middle, rounding up. |
| builder = new BytesBuilder(); |
| builder.add(sublist(latestCrashData, 0, offset)); |
| builder |
| .add(sublist(latestCrashData, offset + mid, latestCrashData.length)); |
| candidate = builder.takeBytes(); |
| fs.data[uri] = candidate; |
| if (await crashesOnCompile(initialComponent)) { |
| crashingAt = mid; |
| } else { |
| // [noLongerCrashingAt] might actually crash now. |
| noLongerCrashingAt = mid - 1; |
| } |
| } |
| |
| // This is basically an assert. |
| builder = new BytesBuilder(); |
| builder.add(sublist(latestCrashData, 0, offset)); |
| builder.add( |
| sublist(latestCrashData, offset + crashingAt, latestCrashData.length)); |
| candidate = builder.takeBytes(); |
| fs.data[uri] = candidate; |
| if (!await crashesOnCompile(initialComponent)) { |
| throw "Error in binary search."; |
| } |
| latestCrashData = candidate; |
| } |
| |
| fs.data[uri] = latestCrashData; |
| } |
| |
| void _tryToRemoveUnreferencedFileContent(Component initialComponent, |
| {bool deleteFile: false}) async { |
| // Check if there now are any unused files. |
| if (_latestComponent == null) return; |
| Set<Uri> neededUris = _latestComponent.uriToSource.keys.toSet(); |
| Map<Uri, Uint8List> copy = new Map.from(fs.data); |
| bool removedSome = false; |
| if (await shouldQuit()) return; |
| for (MapEntry<Uri, Uint8List> entry in fs.data.entries) { |
| if (entry.value == null || entry.value.isEmpty) continue; |
| if (!entry.key.toString().endsWith(".dart")) continue; |
| if (!neededUris.contains(entry.key) && fs.data[entry.key].length != 0) { |
| if (deleteFile) { |
| fs.data[entry.key] = null; |
| } else { |
| fs.data[entry.key] = new Uint8List(0); |
| } |
| print(" => Can probably also delete ${entry.key}"); |
| removedSome = true; |
| } |
| } |
| if (removedSome) { |
| if (await crashesOnCompile(initialComponent)) { |
| print(" => Yes; Could remove those too!"); |
| } else { |
| print(" => No; Couldn't remove those too!"); |
| fs.data.clear(); |
| fs.data.addAll(copy); |
| } |
| } |
| } |
| |
| void deleteContent( |
| List<Uri> uris, int uriIndex, bool limitTo1, Component initialComponent, |
| {bool deleteFile: false}) async { |
| String extraMessageText = "all content of "; |
| if (deleteFile) extraMessageText = ""; |
| |
| if (!limitTo1) { |
| if (await shouldQuit()) return; |
| Map<Uri, Uint8List> copy = new Map.from(fs.data); |
| // Try to remove content of i and the next 9 (10 files in total). |
| for (int j = uriIndex; j < uriIndex + 10 && j < uris.length; j++) { |
| Uri uri = uris[j]; |
| if (deleteFile) { |
| fs.data[uri] = null; |
| } else { |
| fs.data[uri] = new Uint8List(0); |
| } |
| } |
| if (!await crashesOnCompile(initialComponent)) { |
| // Couldn't delete all 10 files. Restore and try the single one. |
| fs.data.clear(); |
| fs.data.addAll(copy); |
| } else { |
| for (int j = uriIndex; j < uriIndex + 10 && j < uris.length; j++) { |
| Uri uri = uris[j]; |
| print("Can delete ${extraMessageText}file $uri"); |
| } |
| await _tryToRemoveUnreferencedFileContent(initialComponent, |
| deleteFile: deleteFile); |
| return; |
| } |
| } |
| |
| if (await shouldQuit()) return; |
| Uri uri = uris[uriIndex]; |
| Uint8List data = fs.data[uri]; |
| if (deleteFile) { |
| fs.data[uri] = null; |
| } else { |
| fs.data[uri] = new Uint8List(0); |
| } |
| if (!await crashesOnCompile(initialComponent)) { |
| print("Can't delete ${extraMessageText}file $uri -- keeping it (for now)"); |
| fs.data[uri] = data; |
| |
| // For dart files we can't truncate completely try to "outline" them |
| // instead. |
| if (uri.toString().endsWith(".dart")) { |
| String textualOutlined = |
| textualOutline(data)?.replaceAll(RegExp(r'\n+'), "\n"); |
| |
| bool outlined = false; |
| if (textualOutlined != null) { |
| Uint8List candidate = utf8.encode(textualOutlined); |
| if (candidate.length != fs.data[uri].length) { |
| if (await shouldQuit()) return; |
| fs.data[uri] = candidate; |
| if (!await crashesOnCompile(initialComponent)) { |
| print("Can't outline the file $uri -- keeping it (for now)"); |
| fs.data[uri] = data; |
| } else { |
| outlined = true; |
| print( |
| "Can outline the file $uri (now ${fs.data[uri].length} bytes)"); |
| } |
| } |
| } |
| if (!outlined) { |
| // We can probably at least remove all comments then... |
| try { |
| List<String> strings = utf8.decode(fs.data[uri]).split("\n"); |
| List<String> stringsLeft = []; |
| for (String string in strings) { |
| if (!string.trim().startsWith("//")) stringsLeft.add(string); |
| } |
| |
| Uint8List candidate = utf8.encode(stringsLeft.join("\n")); |
| if (candidate.length != fs.data[uri].length) { |
| if (await shouldQuit()) return; |
| fs.data[uri] = candidate; |
| if (!await crashesOnCompile(initialComponent)) { |
| print("Can't remove comments for file $uri -- " |
| "keeping it (for now)"); |
| fs.data[uri] = data; |
| } else { |
| print("Removed comments for the file $uri"); |
| } |
| } |
| } catch (e) { |
| // crash in scanner/parser --- keep original file. This crash might |
| // be what we're looking for! |
| } |
| } |
| } |
| } else { |
| print("Can delete ${extraMessageText}file $uri"); |
| await _tryToRemoveUnreferencedFileContent(initialComponent); |
| } |
| } |
| |
| void deleteBlocksOld(Uri uri, Component initialComponent) async { |
| if (uri.toString().endsWith(".json")) { |
| // Try to find annoying |
| // |
| // }, |
| // { |
| // } |
| // |
| // part of json and remove it. |
| Uint8List data = fs.data[uri]; |
| String string = utf8.decode(data); |
| List<String> lines = string.split("\n"); |
| for (int i = 0; i < lines.length - 2; i++) { |
| if (lines[i].trim() == "}," && |
| lines[i + 1].trim() == "{" && |
| lines[i + 2].trim() == "}") { |
| // This is the pattern we wanted to find. Remove it. |
| lines.removeRange(i, i + 2); |
| i--; |
| } |
| } |
| string = lines.join("\n"); |
| fs.data[uri] = utf8.encode(string); |
| if (!await crashesOnCompile(initialComponent)) { |
| // For some reason that didn't work. |
| fs.data[uri] = data; |
| } |
| } |
| if (!uri.toString().endsWith(".dart")) return; |
| |
| Uint8List data = fs.data[uri]; |
| Uint8List latestCrashData = data; |
| |
| List<int> lineStarts = <int>[]; |
| |
| Token firstToken = parser_suite.scanRawBytes(data, |
| nnbd ? scannerConfiguration : scannerConfigurationNonNNBD, lineStarts); |
| |
| if (firstToken == null) { |
| print("Got null token from scanner for $uri"); |
| return; |
| } |
| |
| int compileTry = 0; |
| Token token = firstToken; |
| while (token is ErrorToken) { |
| token = token.next; |
| } |
| List<Replacement> replacements = []; |
| while (token != null && !token.isEof) { |
| bool tryCompile = false; |
| Token skipToToken = token; |
| // Skip very small blocks (e.g. "{}" or "{\n}"); |
| if (token.endGroup != null && token.offset + 3 < token.endGroup.offset) { |
| replacements.add(new Replacement(token.offset, token.endGroup.offset)); |
| tryCompile = true; |
| skipToToken = token.endGroup; |
| } else if (token.lexeme == "@") { |
| if (token.next.next.endGroup != null) { |
| int end = token.next.next.endGroup.offset; |
| skipToToken = token.next.next.endGroup; |
| replacements.add(new Replacement(token.offset - 1, end + 1)); |
| tryCompile = true; |
| } |
| } else if (token.lexeme == "assert") { |
| if (token.next.endGroup != null) { |
| int end = token.next.endGroup.offset; |
| skipToToken = token.next.endGroup; |
| if (token.next.endGroup.next.lexeme == ",") { |
| end = token.next.endGroup.next.offset; |
| skipToToken = token.next.endGroup.next; |
| } |
| // +/- 1 to not include the start and the end character. |
| replacements.add(new Replacement(token.offset - 1, end + 1)); |
| tryCompile = true; |
| } |
| } else if ((token.lexeme == "abstract" && token.next.lexeme == "class") || |
| token.lexeme == "class" || |
| token.lexeme == "enum" || |
| token.lexeme == "mixin" || |
| token.lexeme == "static" || |
| token.next.lexeme == "get" || |
| token.next.lexeme == "set" || |
| token.next.next.lexeme == "(" || |
| (token.next.lexeme == "<" && |
| token.next.endGroup != null && |
| token.next.endGroup.next.next.lexeme == "(")) { |
| // Try to find and remove the entire class/enum/mixin/ |
| // static procedure/getter/setter/simple procedure. |
| Token bracket = token; |
| for (int i = 0; i < 20; i++) { |
| // Find "{", but only go a maximum of 20 tokens to do that. |
| bracket = bracket.next; |
| if (bracket.lexeme == "{" && bracket.endGroup != null) { |
| break; |
| } else if ((bracket.lexeme == "(" || bracket.lexeme == "<") && |
| bracket.endGroup != null) { |
| bracket = bracket.endGroup; |
| } |
| } |
| if (bracket.lexeme == "{" && bracket.endGroup != null) { |
| int end = bracket.endGroup.offset; |
| skipToToken = bracket.endGroup; |
| // +/- 1 to not include the start and the end character. |
| replacements.add(new Replacement(token.offset - 1, end + 1)); |
| tryCompile = true; |
| } |
| } |
| |
| if (tryCompile) { |
| if (await shouldQuit()) break; |
| if (skip) { |
| skip = false; |
| break; |
| } |
| stdout.write("."); |
| compileTry++; |
| if (compileTry % 50 == 0) { |
| stdout.write("(at $compileTry)\n"); |
| } |
| Uint8List candidate = _replaceRange(replacements, data); |
| fs.data[uri] = candidate; |
| if (await crashesOnCompile(initialComponent)) { |
| print("Found block from " |
| "${replacements.last.from} to " |
| "${replacements.last.to} " |
| "that can be removed."); |
| latestCrashData = candidate; |
| token = skipToToken; |
| } else { |
| // Couldn't delete that. |
| replacements.removeLast(); |
| } |
| } |
| token = token.next; |
| } |
| fs.data[uri] = latestCrashData; |
| } |
| |
| void deleteBlocks(final Uri uri, Component initialComponent) async { |
| if (uri.toString().endsWith(".json")) { |
| // Try to find annoying |
| // |
| // }, |
| // { |
| // } |
| // |
| // part of json and remove it. |
| Uint8List data = fs.data[uri]; |
| String string = utf8.decode(data); |
| List<String> lines = string.split("\n"); |
| for (int i = 0; i < lines.length - 2; i++) { |
| if (lines[i].trim() == "}," && |
| lines[i + 1].trim() == "{" && |
| lines[i + 2].trim() == "}") { |
| // This is the pattern we wanted to find. Remove it. |
| lines.removeRange(i, i + 2); |
| i--; |
| } |
| } |
| string = lines.join("\n"); |
| Uint8List candidate = utf8.encode(string); |
| if (candidate.length != data.length) { |
| fs.data[uri] = candidate; |
| if (!await crashesOnCompile(initialComponent)) { |
| // For some reason that didn't work. |
| fs.data[uri] = data; |
| } |
| } |
| |
| // Try to load json and remove blocks. |
| try { |
| Map json = jsonDecode(utf8.decode(data)); |
| Map jsonModified = new Map.from(json); |
| List packages = json["packages"]; |
| List packagesModified = new List.from(packages); |
| jsonModified["packages"] = packagesModified; |
| int i = 0; |
| print("Note there's ${packagesModified.length} packages in .json"); |
| JsonEncoder jsonEncoder = new JsonEncoder.withIndent(" "); |
| while (i < packagesModified.length) { |
| var oldEntry = packagesModified.removeAt(i); |
| String jsonString = jsonEncoder.convert(jsonModified); |
| candidate = utf8.encode(jsonString); |
| Uint8List previous = fs.data[uri]; |
| fs.data[uri] = candidate; |
| if (!await crashesOnCompile(initialComponent)) { |
| // Couldn't remove that part. |
| fs.data[uri] = previous; |
| packagesModified.insert(i, oldEntry); |
| i++; |
| } else { |
| print( |
| "Removed package from .json (${packagesModified.length} left)."); |
| } |
| } |
| } catch (e) { |
| // Couldn't decode it, so don't try to do anything. |
| } |
| return; |
| } |
| if (!uri.toString().endsWith(".dart")) return; |
| |
| Uint8List data = fs.data[uri]; |
| DirectParserASTContentCompilationUnitEnd ast = getAST(data, |
| includeBody: true, |
| includeComments: false, |
| enableExtensionMethods: true, |
| enableNonNullable: nnbd); |
| |
| CompilationHelperClass helper = new CompilationHelperClass(data); |
| |
| // Try to remove top level things on at a time. |
| for (DirectParserASTContent child in ast.children) { |
| bool shouldCompile = false; |
| String what = ""; |
| if (child.isClass()) { |
| DirectParserASTContentClassDeclarationEnd cls = child.asClass(); |
| helper.replacements.add( |
| new Replacement(cls.beginToken.offset - 1, cls.endToken.offset + 1)); |
| shouldCompile = true; |
| what = "class"; |
| } else if (child.isMixinDeclaration()) { |
| DirectParserASTContentMixinDeclarationEnd decl = |
| child.asMixinDeclaration(); |
| helper.replacements.add(new Replacement( |
| decl.mixinKeyword.offset - 1, decl.endToken.offset + 1)); |
| shouldCompile = true; |
| what = "mixin"; |
| } else if (child.isNamedMixinDeclaration()) { |
| DirectParserASTContentNamedMixinApplicationEnd decl = |
| child.asNamedMixinDeclaration(); |
| helper.replacements.add( |
| new Replacement(decl.begin.offset - 1, decl.endToken.offset + 1)); |
| shouldCompile = true; |
| what = "named mixin"; |
| } else if (child.isExtension()) { |
| DirectParserASTContentExtensionDeclarationEnd decl = child.asExtension(); |
| helper.replacements.add(new Replacement( |
| decl.extensionKeyword.offset - 1, decl.endToken.offset + 1)); |
| shouldCompile = true; |
| what = "extension"; |
| } else if (child.isTopLevelFields()) { |
| DirectParserASTContentTopLevelFieldsEnd decl = child.asTopLevelFields(); |
| helper.replacements.add(new Replacement( |
| decl.beginToken.offset - 1, decl.endToken.offset + 1)); |
| shouldCompile = true; |
| what = "toplevel fields"; |
| } else if (child.isTopLevelMethod()) { |
| DirectParserASTContentTopLevelMethodEnd decl = child.asTopLevelMethod(); |
| helper.replacements.add(new Replacement( |
| decl.beginToken.offset - 1, decl.endToken.offset + 1)); |
| shouldCompile = true; |
| what = "toplevel method"; |
| } else if (child.isEnum()) { |
| DirectParserASTContentEnumEnd decl = child.asEnum(); |
| helper.replacements.add(new Replacement( |
| decl.enumKeyword.offset - 1, decl.leftBrace.endGroup.offset + 1)); |
| shouldCompile = true; |
| what = "enum"; |
| } else if (child.isTypedef()) { |
| DirectParserASTContentFunctionTypeAliasEnd decl = child.asTypedef(); |
| helper.replacements.add(new Replacement( |
| decl.typedefKeyword.offset - 1, decl.endToken.offset + 1)); |
| shouldCompile = true; |
| what = "typedef"; |
| } else if (child.isMetadata()) { |
| DirectParserASTContentMetadataStarEnd decl = child.asMetadata(); |
| List<DirectParserASTContentMetadataEnd> metadata = |
| decl.getMetadataEntries(); |
| if (metadata.isNotEmpty) { |
| helper.replacements.add(new Replacement( |
| metadata.first.beginToken.offset - 1, |
| metadata.last.endToken.offset)); |
| shouldCompile = true; |
| } |
| what = "metadata"; |
| } else if (child.isImport()) { |
| DirectParserASTContentImportEnd decl = child.asImport(); |
| helper.replacements.add(new Replacement( |
| decl.importKeyword.offset - 1, decl.semicolon.offset + 1)); |
| shouldCompile = true; |
| what = "import"; |
| } else if (child.isExport()) { |
| DirectParserASTContentExportEnd decl = child.asExport(); |
| helper.replacements.add(new Replacement( |
| decl.exportKeyword.offset - 1, decl.semicolon.offset + 1)); |
| shouldCompile = true; |
| what = "export"; |
| } else if (child.isLibraryName()) { |
| DirectParserASTContentLibraryNameEnd decl = child.asLibraryName(); |
| helper.replacements.add(new Replacement( |
| decl.libraryKeyword.offset - 1, decl.semicolon.offset + 1)); |
| shouldCompile = true; |
| what = "library name"; |
| } else if (child.isPart()) { |
| DirectParserASTContentPartEnd decl = child.asPart(); |
| helper.replacements.add(new Replacement( |
| decl.partKeyword.offset - 1, decl.semicolon.offset + 1)); |
| shouldCompile = true; |
| what = "part"; |
| } else if (child.isPartOf()) { |
| DirectParserASTContentPartOfEnd decl = child.asPartOf(); |
| helper.replacements.add(new Replacement( |
| decl.partKeyword.offset - 1, decl.semicolon.offset + 1)); |
| shouldCompile = true; |
| what = "part of"; |
| } else if (child.isScript()) { |
| var decl = child.asScript(); |
| helper.replacements.add(new Replacement( |
| decl.token.offset - 1, decl.token.offset + decl.token.length)); |
| shouldCompile = true; |
| what = "script"; |
| } |
| |
| if (shouldCompile) { |
| bool success = |
| await _tryReplaceAndCompile(helper, uri, initialComponent, what); |
| if (helper.shouldQuit) return; |
| if (!success) { |
| if (child.isClass()) { |
| // Also try to remove all content of the class. |
| DirectParserASTContentClassDeclarationEnd decl = child.asClass(); |
| DirectParserASTContentClassOrMixinBodyEnd body = |
| decl.getClassOrMixinBody(); |
| if (body.beginToken.offset + 2 < body.endToken.offset) { |
| helper.replacements.add( |
| new Replacement(body.beginToken.offset, body.endToken.offset)); |
| what = "class body"; |
| success = await _tryReplaceAndCompile( |
| helper, uri, initialComponent, what); |
| if (helper.shouldQuit) return; |
| } |
| |
| if (!success) { |
| // Also try to remove members one at a time. |
| for (DirectParserASTContent child in body.children) { |
| shouldCompile = false; |
| if (child is DirectParserASTContentMemberEnd) { |
| if (child.isClassConstructor()) { |
| DirectParserASTContentClassConstructorEnd memberDecl = |
| child.getClassConstructor(); |
| helper.replacements.add(new Replacement( |
| memberDecl.beginToken.offset - 1, |
| memberDecl.endToken.offset + 1)); |
| what = "class constructor"; |
| shouldCompile = true; |
| } else if (child.isClassFields()) { |
| DirectParserASTContentClassFieldsEnd memberDecl = |
| child.getClassFields(); |
| helper.replacements.add(new Replacement( |
| memberDecl.beginToken.offset - 1, |
| memberDecl.endToken.offset + 1)); |
| what = "class fields"; |
| shouldCompile = true; |
| } else if (child.isClassMethod()) { |
| DirectParserASTContentClassMethodEnd memberDecl = |
| child.getClassMethod(); |
| helper.replacements.add(new Replacement( |
| memberDecl.beginToken.offset - 1, |
| memberDecl.endToken.offset + 1)); |
| what = "class method"; |
| shouldCompile = true; |
| } else if (child.isClassFactoryMethod()) { |
| DirectParserASTContentClassFactoryMethodEnd memberDecl = |
| child.getClassFactoryMethod(); |
| helper.replacements.add(new Replacement( |
| memberDecl.beginToken.offset - 1, |
| memberDecl.endToken.offset + 1)); |
| what = "class factory method"; |
| shouldCompile = true; |
| } else { |
| // throw "$child --- ${child.children}"; |
| continue; |
| } |
| } else if (child.isMetadata()) { |
| DirectParserASTContentMetadataStarEnd decl = child.asMetadata(); |
| List<DirectParserASTContentMetadataEnd> metadata = |
| decl.getMetadataEntries(); |
| if (metadata.isNotEmpty) { |
| helper.replacements.add(new Replacement( |
| metadata.first.beginToken.offset - 1, |
| metadata.last.endToken.offset)); |
| shouldCompile = true; |
| } |
| what = "metadata"; |
| } |
| if (shouldCompile) { |
| success = await _tryReplaceAndCompile( |
| helper, uri, initialComponent, what); |
| if (helper.shouldQuit) return; |
| if (!success) { |
| DirectParserASTContentBlockFunctionBodyEnd decl; |
| if (child is DirectParserASTContentMemberEnd) { |
| if (child.isClassMethod()) { |
| decl = child.getClassMethod().getBlockFunctionBody(); |
| } else if (child.isClassConstructor()) { |
| decl = child.getClassConstructor().getBlockFunctionBody(); |
| } |
| } |
| if (decl != null && |
| decl.beginToken.offset + 2 < decl.endToken.offset) { |
| helper.replacements.add(new Replacement( |
| decl.beginToken.offset, decl.endToken.offset)); |
| what = "class member content"; |
| await _tryReplaceAndCompile( |
| helper, uri, initialComponent, what); |
| if (helper.shouldQuit) return; |
| } |
| } |
| } |
| } |
| } |
| |
| // Try to remove "extends", "implements" etc. |
| if (decl.getClassExtends().extendsKeyword != null) { |
| helper.replacements.add(new Replacement( |
| decl.getClassExtends().extendsKeyword.offset - 1, |
| body.beginToken.offset)); |
| what = "class extends"; |
| success = await _tryReplaceAndCompile( |
| helper, uri, initialComponent, what); |
| if (helper.shouldQuit) return; |
| } |
| if (decl.getClassImplements().implementsKeyword != null) { |
| helper.replacements.add(new Replacement( |
| decl.getClassImplements().implementsKeyword.offset - 1, |
| body.beginToken.offset)); |
| what = "class implements"; |
| success = await _tryReplaceAndCompile( |
| helper, uri, initialComponent, what); |
| if (helper.shouldQuit) return; |
| } |
| if (decl.getClassWithClause() != null) { |
| helper.replacements.add(new Replacement( |
| decl.getClassWithClause().withKeyword.offset - 1, |
| body.beginToken.offset)); |
| what = "class with clause"; |
| success = await _tryReplaceAndCompile( |
| helper, uri, initialComponent, what); |
| if (helper.shouldQuit) return; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| class CompilationHelperClass { |
| int compileTry = 0; |
| bool shouldQuit = false; |
| List<Replacement> replacements = []; |
| Uint8List latestCrashData; |
| final Uint8List originalData; |
| |
| CompilationHelperClass(this.originalData) : latestCrashData = originalData; |
| } |
| |
| Future<bool> _tryReplaceAndCompile(CompilationHelperClass data, Uri uri, |
| Component initialComponent, String what) async { |
| if (await shouldQuit()) { |
| data.shouldQuit = true; |
| return false; |
| } |
| stdout.write("."); |
| data.compileTry++; |
| if (data.compileTry % 50 == 0) { |
| stdout.write("(at ${data.compileTry})\n"); |
| } |
| Uint8List candidate = _replaceRange(data.replacements, data.originalData); |
| |
| fs.data[uri] = candidate; |
| if (await crashesOnCompile(initialComponent)) { |
| print("Found $what from " |
| "${data.replacements.last.from} to " |
| "${data.replacements.last.to} " |
| "that can be removed."); |
| data.latestCrashData = candidate; |
| return true; |
| } else { |
| // Couldn't delete that. |
| data.replacements.removeLast(); |
| fs.data[uri] = data.latestCrashData; |
| return false; |
| } |
| } |
| |
| class Replacement implements Comparable<Replacement> { |
| final int from; |
| final int to; |
| final Uint8List nullOrReplacement; |
| |
| Replacement(this.from, this.to, {this.nullOrReplacement}); |
| |
| @override |
| int compareTo(Replacement other) { |
| return from - other.from; |
| } |
| } |
| |
| Uint8List _replaceRange( |
| List<Replacement> unsortedReplacements, Uint8List data) { |
| // The below assumes these are sorted. |
| List<Replacement> sortedReplacements = |
| new List<Replacement>.from(unsortedReplacements)..sort(); |
| final BytesBuilder builder = new BytesBuilder(); |
| int prev = 0; |
| for (int i = 0; i < sortedReplacements.length; i++) { |
| Replacement replacement = sortedReplacements[i]; |
| for (int j = prev; j <= replacement.from; j++) { |
| builder.addByte(data[j]); |
| } |
| if (replacement.nullOrReplacement != null) { |
| builder.add(replacement.nullOrReplacement); |
| } |
| prev = replacement.to; |
| } |
| for (int j = prev; j < data.length; j++) { |
| builder.addByte(data[j]); |
| } |
| Uint8List candidate = builder.takeBytes(); |
| return candidate; |
| } |
| |
| const int $LF = 10; |
| |
| void deleteEmptyLines(Uri uri, Component initialComponent) async { |
| Uint8List data = fs.data[uri]; |
| List<Uint8List> lines = []; |
| int start = 0; |
| for (int i = 0; i < data.length; i++) { |
| if (data[i] == $LF) { |
| if (i - start > 0) { |
| lines.add(sublist(data, start, i)); |
| } |
| start = i + 1; |
| } |
| } |
| if (data.length - start > 0) { |
| lines.add(sublist(data, start, data.length)); |
| } |
| |
| final BytesBuilder builder = new BytesBuilder(); |
| for (int j = 0; j < lines.length; j++) { |
| if (builder.isNotEmpty) { |
| builder.addByte($LF); |
| } |
| builder.add(lines[j]); |
| } |
| Uint8List candidate = builder.takeBytes(); |
| if (candidate.length == data.length) return; |
| |
| if (await shouldQuit()) return; |
| fs.data[uri] = candidate; |
| if (!await crashesOnCompile(initialComponent)) { |
| // For some reason the empty lines are important. |
| fs.data[uri] = data; |
| } else { |
| print("\nDeleted empty lines."); |
| } |
| } |
| |
| void deleteLines(Uri uri, Component initialComponent) async { |
| // Try to delete "lines". |
| Uint8List data = fs.data[uri]; |
| List<Uint8List> lines = []; |
| int start = 0; |
| for (int i = 0; i < data.length; i++) { |
| if (data[i] == $LF) { |
| lines.add(sublist(data, start, i)); |
| start = i + 1; |
| } |
| } |
| lines.add(sublist(data, start, data.length)); |
| List<bool> include = new List.filled(lines.length, true); |
| Uint8List latestCrashData = data; |
| int length = 1; |
| int i = 0; |
| while (i < lines.length) { |
| if (await shouldQuit()) break; |
| if (skip) { |
| skip = false; |
| break; |
| } |
| stdout.write("."); |
| if (i % 50 == 0) { |
| stdout.write("(at $i of ${lines.length})\n"); |
| } |
| if (i + length > lines.length) { |
| length = lines.length - i; |
| } |
| for (int j = i; j < i + length; j++) { |
| include[j] = false; |
| } |
| final BytesBuilder builder = new BytesBuilder(); |
| for (int j = 0; j < lines.length; j++) { |
| if (include[j]) { |
| if (builder.isNotEmpty) { |
| builder.addByte($LF); |
| } |
| builder.add(lines[j]); |
| } |
| } |
| Uint8List candidate = builder.takeBytes(); |
| fs.data[uri] = candidate; |
| if (!await crashesOnCompile(initialComponent)) { |
| // Didn't crash => Can't remove line i-j. |
| for (int j = i; j < i + length; j++) { |
| include[j] = true; |
| } |
| if (length > 2) { |
| // Retry with length 2 at same i. |
| // The idea here is that for instance formatted json might have lines |
| // looking like |
| // { |
| // } |
| // where deleting just one line makes it invalid. |
| length = 2; |
| } else if (length > 1) { |
| // Retry with length 1 at same i. |
| length = 1; |
| } else { |
| // Couldn't with length 1 either. |
| i++; |
| } |
| } else { |
| print("\nCan delete line $i (inclusive) - ${i + length} (exclusive) " |
| "(of ${lines.length})"); |
| latestCrashData = candidate; |
| i += length; |
| length *= 2; |
| } |
| } |
| fs.data[uri] = latestCrashData; |
| } |
| |
| Component _latestComponent; |
| IncrementalCompiler _latestIncrementalCompiler; |
| |
| Future<bool> crashesOnCompile(Component initialComponent) async { |
| IncrementalCompiler incrementalCompiler; |
| if (noPlatform) { |
| incrementalCompiler = new IncrementalCompiler(setupCompilerContext()); |
| } else { |
| incrementalCompiler = new IncrementalCompiler.fromComponent( |
| setupCompilerContext(), initialComponent); |
| } |
| _latestIncrementalCompiler = incrementalCompiler; |
| incrementalCompiler.invalidate(mainUri); |
| try { |
| _latestComponent = await incrementalCompiler.computeDelta(); |
| if (serialize) { |
| ByteSink sink = new ByteSink(); |
| BinaryPrinter printer = new BinaryPrinter(sink); |
| printer.writeComponentFile(_latestComponent); |
| sink.builder.takeBytes(); |
| } |
| for (Uri uri in invalidate) { |
| incrementalCompiler.invalidate(uri); |
| Component delta = await incrementalCompiler.computeDelta(); |
| if (serialize) { |
| ByteSink sink = new ByteSink(); |
| BinaryPrinter printer = new BinaryPrinter(sink); |
| printer.writeComponentFile(delta); |
| sink.builder.takeBytes(); |
| } |
| } |
| _latestComponent = null; // if it didn't crash this isn't relevant. |
| return false; |
| } catch (e, st) { |
| // Find line with #0 in it. |
| String eWithSt = "$e\n\n$st"; |
| List<String> lines = eWithSt.split("\n"); |
| String foundLine = ""; |
| int lookFor = 0; |
| for (String line in lines) { |
| if (line.startsWith("#$lookFor")) { |
| foundLine += line; |
| lookFor++; |
| if (lookFor >= stackTraceMatches) { |
| break; |
| } else { |
| foundLine += "\n"; |
| } |
| } |
| } |
| if (foundLine == null) throw "Unexpected crash without stacktrace: $e"; |
| if (expectedCrashLine == null) { |
| print("Got '$foundLine'"); |
| expectedCrashLine = foundLine; |
| return true; |
| } else if (foundLine == expectedCrashLine) { |
| return true; |
| } else { |
| if (askAboutRedirectCrashTarget && |
| !askedAboutRedirect.contains(foundLine)) { |
| print("Crashed, but another place: $foundLine"); |
| while (true) { |
| askedAboutRedirect.add(foundLine); |
| print(eWithSt); |
| print("Should we redirect to searching for that? (y/n)"); |
| String answer = stdin.readLineSync(); |
| if (answer == "yes" || answer == "y") { |
| expectedCrashLine = foundLine; |
| return true; |
| } else if (answer == "no" || answer == "n") { |
| break; |
| } else { |
| print("Didn't get that answer. " |
| "Please answer 'yes, 'y', 'no' or 'n'"); |
| } |
| } |
| } |
| return false; |
| } |
| } |
| } |
| |
| Future<Component> getInitialComponent() async { |
| IncrementalCompiler incrementalCompiler = |
| new IncrementalCompiler(setupCompilerContext()); |
| Component originalComponent = await incrementalCompiler.computeDelta(); |
| return originalComponent; |
| } |
| |
| CompilerContext setupCompilerContext() { |
| CompilerOptions options = getOptions(); |
| |
| if (nnbd) { |
| options.explicitExperimentalFlags = {ExperimentalFlag.nonNullable: true}; |
| } |
| if (experimentalInvalidation) { |
| options.explicitExperimentalFlags ??= {}; |
| options.explicitExperimentalFlags[ |
| ExperimentalFlag.alternativeInvalidationStrategy] = true; |
| } |
| |
| TargetFlags targetFlags = new TargetFlags( |
| enableNullSafety: nnbd, trackWidgetCreation: widgetTransformation); |
| Target target; |
| switch (targetString) { |
| case "VM": |
| target = new VmTarget(targetFlags); |
| break; |
| case "flutter": |
| target = new FlutterTarget(targetFlags); |
| break; |
| case "ddc": |
| target = new DevCompilerTarget(targetFlags); |
| break; |
| default: |
| throw "Unknown target '$target'"; |
| } |
| options.target = target; |
| options.fileSystem = fs; |
| options.sdkRoot = null; |
| options.sdkSummary = platformUri; |
| options.omitPlatform = false; |
| options.onDiagnostic = (DiagnosticMessage message) { |
| // don't care. |
| }; |
| if (noPlatform) { |
| options.librariesSpecificationUri = null; |
| } |
| |
| CompilerContext compilerContext = new CompilerContext( |
| new ProcessedOptions(options: options, inputs: [mainUri])); |
| return compilerContext; |
| } |
| |
| String getFileAsStringContent(Uint8List rawBytes, bool nnbd) { |
| List<int> lineStarts = <int>[]; |
| |
| Token firstToken = parser_suite.scanRawBytes(rawBytes, |
| nnbd ? scannerConfiguration : scannerConfigurationNonNNBD, lineStarts); |
| |
| if (firstToken == null) { |
| throw "Got null token from scanner"; |
| } |
| |
| ParserTestListener parserTestListener = new ParserTestListener(false); |
| Parser parser = new Parser(parserTestListener); |
| parser.parseUnit(firstToken); |
| String parsedString = |
| parser_suite.tokenStreamToString(firstToken, lineStarts).toString(); |
| return parsedString; |
| } |
| |
| ScannerConfiguration scannerConfiguration = new ScannerConfiguration( |
| enableTripleShift: true, |
| enableExtensionMethods: true, |
| enableNonNullable: true); |
| |
| ScannerConfiguration scannerConfigurationNonNNBD = new ScannerConfiguration( |
| enableTripleShift: true, |
| enableExtensionMethods: true, |
| enableNonNullable: false); |
| |
| class FakeFileSystem extends FileSystem { |
| bool _redirectAndRecord = true; |
| bool _initialized = false; |
| final Map<Uri, Uint8List> data = {}; |
| |
| @override |
| FileSystemEntity entityForUri(Uri uri) { |
| return new FakeFileSystemEntity(this, uri); |
| } |
| |
| initializeFromJson(Map<String, dynamic> json) { |
| _initialized = true; |
| _redirectAndRecord = json['_redirectAndRecord']; |
| data.clear(); |
| List tmp = json['data']; |
| for (int i = 0; i < tmp.length; i += 2) { |
| Uri key = tmp[i] == null ? null : Uri.parse(tmp[i]); |
| if (tmp[i + 1] == null) { |
| data[key] = null; |
| } else if (tmp[i + 1] is String) { |
| data[key] = utf8.encode(tmp[i + 1]); |
| } else { |
| data[key] = Uint8List.fromList(new List<int>.from(tmp[i + 1])); |
| } |
| } |
| } |
| |
| Map<String, dynamic> toJson() { |
| List tmp = []; |
| for (var entry in data.entries) { |
| if (entry.value == null) continue; |
| tmp.add(entry.key == null ? null : entry.key.toString()); |
| dynamic out = entry.value; |
| if (entry.value != null && entry.value.isNotEmpty) { |
| try { |
| String string = utf8.decode(entry.value); |
| out = string; |
| } catch (e) { |
| // not a string... |
| } |
| } |
| tmp.add(out); |
| } |
| return { |
| '_redirectAndRecord': _redirectAndRecord, |
| 'data': tmp, |
| }; |
| } |
| } |
| |
| class FakeFileSystemEntity extends FileSystemEntity { |
| final FakeFileSystem fs; |
| final Uri uri; |
| FakeFileSystemEntity(this.fs, this.uri); |
| |
| void _ensureCachedIfOk() { |
| if (fs.data.containsKey(uri)) return; |
| if (fs._initialized) return; |
| if (!fs._redirectAndRecord) { |
| throw "Asked for file in non-recording mode that wasn't known"; |
| } |
| File f = new File.fromUri(uri); |
| if (!f.existsSync()) { |
| fs.data[uri] = null; |
| return; |
| } |
| fs.data[uri] = f.readAsBytesSync(); |
| } |
| |
| @override |
| Future<bool> exists() { |
| _ensureCachedIfOk(); |
| Uint8List data = fs.data[uri]; |
| if (data == null) return Future.value(false); |
| return Future.value(true); |
| } |
| |
| @override |
| Future<List<int>> readAsBytes() { |
| _ensureCachedIfOk(); |
| Uint8List data = fs.data[uri]; |
| if (data == null) throw new FileSystemException(uri, "File doesn't exist."); |
| return Future.value(data); |
| } |
| |
| @override |
| Future<String> readAsString() { |
| _ensureCachedIfOk(); |
| Uint8List data = fs.data[uri]; |
| if (data == null) throw new FileSystemException(uri, "File doesn't exist."); |
| return Future.value(utf8.decode(data)); |
| } |
| } |
