Disable source maps completely.

dart/pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
 
-  SsaFunctionCompiler(JavaScriptBackend backend)
+  SsaFunctionCompiler(JavaScriptBackend backend, bool generateSourceMap)
       : generator = new SsaCodeGeneratorTask(backend),
-        builder = new SsaBuilderTask(backend),
+        builder = new SsaBuilderTask(backend, generateSourceMap),
         optimizer = new SsaOptimizerTask(backend);
 
   /// Generates JavaScript code for `work.element`.
   /// Using the ssa builder, optimizer and codegenerator.
   js.Fun compile(CodegenWorkItem work) {
     HGraph graph = builder.build(work);
     optimizer.optimize(work, graph);
     return generator.generateCode(work, graph);
   }
 
   Iterable<CompilerTask> get tasks {
     return <CompilerTask>[builder, optimizer, generator];
   }
 }
 
 /// A synthetic local variable only used with the SSA graph.
 ///
 /// For instance used for holding return value of function or the exception of a
 /// try-catch statement.
 class SyntheticLocal extends Local {
   final String name;
   final ExecutableElement executableContext;
 
   SyntheticLocal(this.name, this.executableContext);
 }
 
 class SsaBuilderTask extends CompilerTask {
   final CodeEmitterTask emitter;
   final JavaScriptBackend backend;
+  final bool generateSourceMap;
 
   String get name => 'SSA builder';
 
-  SsaBuilderTask(JavaScriptBackend backend)
+  SsaBuilderTask(JavaScriptBackend backend, this.generateSourceMap)
     : emitter = backend.emitter,
       backend = backend,
       super(backend.compiler);
 
   HGraph build(CodegenWorkItem work) {
     return measure(() {
       Element element = work.element.implementation;
       return compiler.withCurrentElement(element, () {
         HInstruction.idCounter = 0;
         SsaBuilder builder =
-            new SsaBuilder(backend, work, emitter.nativeEmitter);
+            new SsaBuilder(
+                backend, work, emitter.nativeEmitter, generateSourceMap);
         HGraph graph;
         ElementKind kind = element.kind;
         if (kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
           graph = compileConstructor(builder, work);
         } else if (kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY ||
                    kind == ElementKind.FUNCTION ||
                    kind == ElementKind.GETTER ||
                    kind == ElementKind.SETTER) {
           graph = builder.buildMethod(element);
         } else if (kind == ElementKind.FIELD) {
@@ skipping 855 matching lines @@
 
 /**
  * This class builds SSA nodes for functions represented in AST.
  */
 class SsaBuilder extends ResolvedVisitor {
   final Compiler compiler;
   final JavaScriptBackend backend;
   final ConstantSystem constantSystem;
   final CodegenWorkItem work;
   final RuntimeTypes rti;
+  final bool generateSourceMap;
 
   /* This field is used by the native handler. */
   final NativeEmitter nativeEmitter;
 
   final HGraph graph = new HGraph();
 
   /**
    * The current block to add instructions to. Might be null, if we are
    * visiting dead code, but see [isReachable].
    */
@@ skipping 58 matching lines @@
    * accessed indirectly through [HLocalGet] and [HLocalSet].
    */
   Map<Local, HLocalValue> activationVariables =
       <Local, HLocalValue>{};
 
   // We build the Ssa graph by simulating a stack machine.
   List<HInstruction> stack = <HInstruction>[];
 
   SsaBuilder(JavaScriptBackend backend,
              CodegenWorkItem work,
-             this.nativeEmitter)
+             this.nativeEmitter,
+             this.generateSourceMap)
     : this.compiler = backend.compiler,
       this.backend = backend,
       this.constantSystem = backend.constantSystem,
       this.work = work,
       this.rti = backend.rti,
       super(work.resolutionTree) {
     localsHandler = new LocalsHandler(this, work.element);
     sourceElementStack.add(work.element);
   }
 
@@ skipping 1384 matching lines @@
           value,
           compiler.boolClass.rawType,
           kind: HTypeConversion.BOOLEAN_CONVERSION_CHECK);
     }
     HInstruction result = new HBoolify(value, backend.boolType);
     add(result);
     return result;
   }
 
   HInstruction attachPosition(HInstruction target, ast.Node node) {
-    if (node != null) {
+    if (generateSourceMap && node != null) {
       target.sourcePosition = sourceFileLocationForBeginToken(node);
     }
     return target;
   }
 
   SourceFileLocation sourceFileLocationForBeginToken(ast.Node node) =>
       sourceFileLocationForToken(node, node.getBeginToken());
 
   SourceFileLocation sourceFileLocationForEndToken(ast.Node node) =>
       sourceFileLocationForToken(node, node.getEndToken());
@@ skipping 4178 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }