| OLD | NEW |
| 1 // Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file |
| 2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
| 3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
| 4 | 4 |
| 5 /// Command line tool to run the checker on a Dart program. | |
| 6 library dev_compiler.devc; | 5 library dev_compiler.devc; |
| 7 | 6 |
| 8 import 'dart:async'; | 7 export 'src/analysis_context.dart' |
| 9 import 'dart:convert'; | 8 show createAnalysisContext, createAnalysisContextWithSources; |
| 10 import 'dart:io'; | 9 export 'src/compiler.dart' show BatchCompiler, setupLogger, createErrorReporter; |
| 11 | 10 export 'src/server/server.dart' show DevServer; |
| 12 import 'package:analyzer/src/generated/engine.dart' | 11 export 'strong_mode.dart' show StrongModeOptions; |
| 13 show AnalysisContext, ChangeSet; | |
| 14 import 'package:analyzer/src/generated/error.dart' | |
| 15 show AnalysisError, AnalysisErrorListener, ErrorSeverity, ErrorType; | |
| 16 import 'package:analyzer/src/generated/source.dart' show Source; | |
| 17 import 'package:logging/logging.dart' show Level, Logger, LogRecord; | |
| 18 import 'package:path/path.dart' as path; | |
| 19 import 'package:shelf/shelf.dart' as shelf; | |
| 20 import 'package:shelf/shelf_io.dart' as shelf; | |
| 21 import 'package:shelf_static/shelf_static.dart' as shelf_static; | |
| 22 | |
| 23 import 'src/analysis_context.dart'; | |
| 24 import 'src/checker/checker.dart'; | |
| 25 import 'src/checker/rules.dart'; | |
| 26 import 'src/codegen/code_generator.dart' show CodeGenerator; | |
| 27 import 'src/codegen/html_codegen.dart'; | |
| 28 import 'src/codegen/js_codegen.dart'; | |
| 29 import 'src/dependency_graph.dart'; | |
| 30 import 'src/info.dart' | |
| 31 show AnalyzerMessage, CheckerResults, LibraryInfo, LibraryUnit; | |
| 32 import 'src/options.dart'; | |
| 33 import 'src/report.dart'; | |
| 34 import 'src/utils.dart'; | |
| 35 | |
| 36 /// Sets up the type checker logger to print a span that highlights error | |
| 37 /// messages. | |
| 38 StreamSubscription setupLogger(Level level, printFn) { | |
| 39 Logger.root.level = level; | |
| 40 return Logger.root.onRecord.listen((LogRecord rec) { | |
| 41 printFn('${rec.level.name.toLowerCase()}: ${rec.message}'); | |
| 42 }); | |
| 43 } | |
| 44 | |
| 45 abstract class AbstractCompiler { | |
| 46 CompilerOptions get options; | |
| 47 AnalysisContext get context; | |
| 48 TypeRules get rules; | |
| 49 Uri get entryPointUri; | |
| 50 } | |
| 51 | |
| 52 /// Encapsulates the logic to do a one-off compilation or a partial compilation | |
| 53 /// when the compiler is run as a development server. | |
| 54 class Compiler implements AbstractCompiler { | |
| 55 final CompilerOptions options; | |
| 56 final AnalysisContext context; | |
| 57 final AnalysisErrorListener _reporter; | |
| 58 final TypeRules rules; | |
| 59 final CodeChecker _checker; | |
| 60 final SourceNode _entryNode; | |
| 61 List<LibraryInfo> _libraries = <LibraryInfo>[]; | |
| 62 final _generators = <CodeGenerator>[]; | |
| 63 bool _hashing; | |
| 64 bool _failure = false; | |
| 65 | |
| 66 factory Compiler(CompilerOptions options, | |
| 67 {AnalysisContext context, AnalysisErrorListener reporter}) { | |
| 68 var strongOpts = options.strongOptions; | |
| 69 var sourceOpts = options.sourceOptions; | |
| 70 if (context == null) { | |
| 71 context = createAnalysisContextWithSources(strongOpts, sourceOpts); | |
| 72 } | |
| 73 | |
| 74 if (reporter == null) { | |
| 75 reporter = options.dumpInfo | |
| 76 ? new SummaryReporter(context, options.logLevel) | |
| 77 : new LogReporter(context, useColors: options.useColors); | |
| 78 } | |
| 79 var graph = new SourceGraph(context, reporter, options); | |
| 80 var rules = new RestrictedRules(context.typeProvider, | |
| 81 options: options.strongOptions); | |
| 82 var checker = new CodeChecker(rules, reporter, strongOpts); | |
| 83 | |
| 84 var inputFile = sourceOpts.entryPointFile; | |
| 85 var inputUri = inputFile.startsWith('dart:') || | |
| 86 inputFile.startsWith('package:') | |
| 87 ? Uri.parse(inputFile) | |
| 88 : new Uri.file(path.absolute(sourceOpts.useImplicitHtml | |
| 89 ? SourceResolverOptions.implicitHtmlFile | |
| 90 : inputFile)); | |
| 91 var entryNode = graph.nodeFromUri(inputUri); | |
| 92 | |
| 93 return new Compiler._( | |
| 94 options, context, reporter, rules, checker, entryNode); | |
| 95 } | |
| 96 | |
| 97 Compiler._(this.options, this.context, this._reporter, this.rules, | |
| 98 this._checker, this._entryNode) { | |
| 99 if (outputDir != null) { | |
| 100 _generators.add(new JSGenerator(this)); | |
| 101 } | |
| 102 // TODO(sigmund): refactor to support hashing of the dart output? | |
| 103 _hashing = options.enableHashing && _generators.length == 1; | |
| 104 } | |
| 105 | |
| 106 Uri get entryPointUri => _entryNode.uri; | |
| 107 String get outputDir => options.codegenOptions.outputDir; | |
| 108 | |
| 109 bool _buildSource(SourceNode node) { | |
| 110 if (node is HtmlSourceNode) { | |
| 111 _buildHtmlFile(node); | |
| 112 } else if (node is DartSourceNode) { | |
| 113 _buildDartLibrary(node); | |
| 114 } else if (node is ResourceSourceNode) { | |
| 115 _buildResourceFile(node); | |
| 116 } else { | |
| 117 assert(false); // should not get a build request on PartSourceNode | |
| 118 } | |
| 119 | |
| 120 // TODO(sigmund): don't always return true. Use summarization to better | |
| 121 // determine when rebuilding is needed. | |
| 122 return true; | |
| 123 } | |
| 124 | |
| 125 void _buildHtmlFile(HtmlSourceNode node) { | |
| 126 if (outputDir == null) return; | |
| 127 var output = generateEntryHtml(node, options); | |
| 128 if (output == null) { | |
| 129 _failure = true; | |
| 130 return; | |
| 131 } | |
| 132 var filename = path.basename(node.uri.path); | |
| 133 String outputFile = path.join(outputDir, filename); | |
| 134 new File(outputFile).writeAsStringSync(output); | |
| 135 } | |
| 136 | |
| 137 void _buildResourceFile(ResourceSourceNode node) { | |
| 138 // ResourceSourceNodes files that just need to be copied over to the output | |
| 139 // location. These can be external dependencies or pieces of the | |
| 140 // dev_compiler runtime. | |
| 141 if (outputDir == null) return; | |
| 142 var filepath = | |
| 143 resourceOutputPath(node.uri, _entryNode.uri, options.runtimeDir); | |
| 144 assert(filepath != null); | |
| 145 filepath = path.join(outputDir, filepath); | |
| 146 var dir = path.dirname(filepath); | |
| 147 new Directory(dir).createSync(recursive: true); | |
| 148 new File.fromUri(node.source.uri).copySync(filepath); | |
| 149 if (_hashing) node.cachingHash = computeHashFromFile(filepath); | |
| 150 } | |
| 151 | |
| 152 bool _isEntry(DartSourceNode node) { | |
| 153 if (_entryNode is DartSourceNode) return _entryNode == node; | |
| 154 return (_entryNode as HtmlSourceNode).scripts.contains(node); | |
| 155 } | |
| 156 | |
| 157 void _buildDartLibrary(DartSourceNode node) { | |
| 158 var source = node.source; | |
| 159 // TODO(sigmund): find out from analyzer team if there is a better way | |
| 160 context.applyChanges(new ChangeSet()..changedSource(source)); | |
| 161 var entryUnit = context.resolveCompilationUnit2(source, source); | |
| 162 var lib = entryUnit.element.enclosingElement; | |
| 163 if (!options.checkSdk && lib.source.uri.scheme == 'dart') return; | |
| 164 var current = node.info; | |
| 165 if (current != null) { | |
| 166 assert(current.library == lib); | |
| 167 } else { | |
| 168 node.info = current = new LibraryInfo(lib, _isEntry(node)); | |
| 169 } | |
| 170 _libraries.add(current); | |
| 171 rules.currentLibraryInfo = current; | |
| 172 | |
| 173 var resolvedParts = node.parts | |
| 174 .map((p) => context.resolveCompilationUnit2(p.source, source)) | |
| 175 .toList(growable: false); | |
| 176 var libraryUnit = new LibraryUnit(entryUnit, resolvedParts); | |
| 177 bool failureInLib = false; | |
| 178 for (var unit in libraryUnit.libraryThenParts) { | |
| 179 var unitSource = unit.element.source; | |
| 180 failureInLib = logErrors(unitSource) || failureInLib; | |
| 181 _checker.visitCompilationUnit(unit); | |
| 182 if (_checker.failure) failureInLib = true; | |
| 183 } | |
| 184 if (failureInLib) { | |
| 185 _failure = true; | |
| 186 if (!options.codegenOptions.forceCompile) return; | |
| 187 } | |
| 188 | |
| 189 for (var cg in _generators) { | |
| 190 var hash = cg.generateLibrary(libraryUnit, current); | |
| 191 if (_hashing) node.cachingHash = hash; | |
| 192 } | |
| 193 } | |
| 194 | |
| 195 /// Log any errors encountered when resolving [source] and return whether any | |
| 196 /// errors were found. | |
| 197 bool logErrors(Source source) { | |
| 198 context.computeErrors(source); | |
| 199 List<AnalysisError> errors = context.getErrors(source).errors; | |
| 200 bool failure = false; | |
| 201 if (errors.isNotEmpty) { | |
| 202 for (var error in errors) { | |
| 203 // Always skip TODOs. | |
| 204 if (error.errorCode.type == ErrorType.TODO) continue; | |
| 205 | |
| 206 // Skip hints for now. In the future these could be turned on via flags. | |
| 207 if (error.errorCode.errorSeverity.ordinal < | |
| 208 ErrorSeverity.WARNING.ordinal) { | |
| 209 continue; | |
| 210 } | |
| 211 | |
| 212 // All analyzer warnings or errors are errors for DDC. | |
| 213 failure = true; | |
| 214 _reporter.onError(error); | |
| 215 } | |
| 216 } | |
| 217 return failure; | |
| 218 } | |
| 219 | |
| 220 CheckerResults run() { | |
| 221 var clock = new Stopwatch()..start(); | |
| 222 | |
| 223 // TODO(sigmund): we are missing a couple failures here. The | |
| 224 // dependency_graph now detects broken imports or unsupported features | |
| 225 // like more than one script tag (see .severe messages in | |
| 226 // dependency_graph.dart). Such failures should be reported back | |
| 227 // here so we can mark failure=true in the CheckerResutls. | |
| 228 rebuild(_entryNode, _buildSource); | |
| 229 _dumpInfoIfRequested(); | |
| 230 clock.stop(); | |
| 231 var time = (clock.elapsedMilliseconds / 1000).toStringAsFixed(2); | |
| 232 _log.fine('Compiled ${_libraries.length} libraries in ${time} s\n'); | |
| 233 return new CheckerResults( | |
| 234 _libraries, rules, _failure || options.codegenOptions.forceCompile); | |
| 235 } | |
| 236 | |
| 237 void _runAgain() { | |
| 238 var clock = new Stopwatch()..start(); | |
| 239 _libraries = <LibraryInfo>[]; | |
| 240 int changed = 0; | |
| 241 | |
| 242 // TODO(sigmund): propagate failures here (see TODO in run). | |
| 243 rebuild(_entryNode, (n) { | |
| 244 changed++; | |
| 245 return _buildSource(n); | |
| 246 }); | |
| 247 clock.stop(); | |
| 248 if (changed > 0) _dumpInfoIfRequested(); | |
| 249 var time = (clock.elapsedMilliseconds / 1000).toStringAsFixed(2); | |
| 250 _log.fine("Compiled ${changed} libraries in ${time} s\n"); | |
| 251 } | |
| 252 | |
| 253 _dumpInfoIfRequested() { | |
| 254 if (!options.dumpInfo || _reporter is! SummaryReporter) return; | |
| 255 var result = (_reporter as SummaryReporter).result; | |
| 256 if (!options.serverMode) print(summaryToString(result)); | |
| 257 var filepath = options.serverMode | |
| 258 ? path.join(outputDir, 'messages.json') | |
| 259 : options.dumpInfoFile; | |
| 260 if (filepath == null) return; | |
| 261 new File(filepath).writeAsStringSync(JSON.encode(result.toJsonMap())); | |
| 262 } | |
| 263 } | |
| 264 | |
| 265 class CompilerServer { | |
| 266 final Compiler compiler; | |
| 267 final String outDir; | |
| 268 final String host; | |
| 269 final int port; | |
| 270 final String _entryPath; | |
| 271 | |
| 272 factory CompilerServer(CompilerOptions options) { | |
| 273 var entryPath = path.basename(options.sourceOptions.entryPointFile); | |
| 274 var extension = path.extension(entryPath); | |
| 275 if (extension != '.html' && !options.sourceOptions.useImplicitHtml) { | |
| 276 print('error: devc in server mode requires an HTML or Dart entry point.'); | |
| 277 exit(1); | |
| 278 } | |
| 279 | |
| 280 // TODO(sigmund): allow running without a dir, but keep output in memory? | |
| 281 var outDir = options.codegenOptions.outputDir; | |
| 282 if (outDir == null) { | |
| 283 print('error: devc in server mode also requires specifying and ' | |
| 284 'output location for generated code.'); | |
| 285 exit(1); | |
| 286 } | |
| 287 var port = options.port; | |
| 288 var host = options.host; | |
| 289 var compiler = new Compiler(options); | |
| 290 return new CompilerServer._(compiler, outDir, host, port, entryPath); | |
| 291 } | |
| 292 | |
| 293 CompilerServer._( | |
| 294 Compiler compiler, this.outDir, this.host, this.port, String entryPath) | |
| 295 : this.compiler = compiler, | |
| 296 // TODO(jmesserly): this logic is duplicated in a few places | |
| 297 this._entryPath = compiler.options.sourceOptions.useImplicitHtml | |
| 298 ? SourceResolverOptions.implicitHtmlFile | |
| 299 : entryPath; | |
| 300 | |
| 301 Future start() async { | |
| 302 // Create output directory if needed. shelf_static will fail otherwise. | |
| 303 var out = new Directory(outDir); | |
| 304 if (!await out.exists()) await out.create(recursive: true); | |
| 305 | |
| 306 var handler = const shelf.Pipeline() | |
| 307 .addMiddleware(rebuildAndCache) | |
| 308 .addHandler(shelf_static.createStaticHandler(outDir, | |
| 309 defaultDocument: _entryPath)); | |
| 310 await shelf.serve(handler, host, port); | |
| 311 print('Serving $_entryPath at http://$host:$port/'); | |
| 312 compiler.run(); | |
| 313 } | |
| 314 | |
| 315 shelf.Handler rebuildAndCache(shelf.Handler handler) => (request) { | |
| 316 print('requested $GREEN_COLOR${request.url}$NO_COLOR'); | |
| 317 // Trigger recompile only when requesting the HTML page. | |
| 318 var segments = request.url.pathSegments; | |
| 319 bool isEntryPage = segments.length == 0 || segments[0] == _entryPath; | |
| 320 if (isEntryPage) compiler._runAgain(); | |
| 321 | |
| 322 // To help browsers cache resources that don't change, we serve these | |
| 323 // resources by adding a query parameter containing their hash: | |
| 324 // /{path-to-file.js}?____cached={hash} | |
| 325 var hash = request.url.queryParameters['____cached']; | |
| 326 var response = handler(request); | |
| 327 var policy = hash != null ? 'max-age=${24 * 60 * 60}' : 'no-cache'; | |
| 328 var headers = {'cache-control': policy}; | |
| 329 if (hash != null) { | |
| 330 // Note: the cache-control header should be enough, but this doesn't hurt | |
| 331 // and can help renew the policy after it expires. | |
| 332 headers['ETag'] = hash; | |
| 333 } | |
| 334 return response.change(headers: headers); | |
| 335 }; | |
| 336 } | |
| 337 | |
| 338 final _log = new Logger('dev_compiler'); | |
| 339 final _earlyErrorResult = new CheckerResults(const [], null, true); | |
| OLD | NEW |