Revert "fix #30138, synethic nodes causing crash generating source maps"

pkg/dev_compiler/lib/src/compiler/code_generator.dart

 // Copyright (c) 2015, 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:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 565 matching lines @@
     }
   }
 
   @override
   visitCompilationUnit(CompilationUnit unit) {
     // NOTE: this method isn't the right place to initialize
     // per-compilation-unit state. Declarations can be visited out of order,
     // this is only to catch things that haven't been emitted yet.
     //
     // See _emitTypeDeclaration.
-    _currentElements.add(unit.element);
-    var isInternalSdk = isSdkInternalRuntime(currentLibrary);
+    var library = unit.element.library;
+    bool internalSdk = isSdkInternalRuntime(library);
+    _currentElements.add(library);
     List<VariableDeclaration> fields;
     for (var declaration in unit.declarations) {
       if (declaration is TopLevelVariableDeclaration) {
         inferNullableTypes(declaration);
-        if (isInternalSdk && declaration.variables.isFinal) {
+        if (internalSdk && declaration.variables.isFinal) {
           _emitInternalSdkFields(declaration.variables.variables);
         } else {
           (fields ??= []).addAll(declaration.variables.variables);
         }
         continue;
       }
 
       if (fields != null) {
         _emitTopLevelFields(fields);
         fields = null;
       }
 
       var element = declaration.element;
       if (element is TypeDefiningElement) {
         _emitTypeDeclaration(element);
         continue;
       }
 
       inferNullableTypes(declaration);
       var item = _visit(declaration);
-      if (isInternalSdk && element is FunctionElement) {
+      if (internalSdk && element is FunctionElement) {
         _internalSdkFunctions.add(item);
       } else {
         _moduleItems.add(item);
       }
     }
 
     if (fields != null) _emitTopLevelFields(fields);
 
     _currentElements.removeLast();
   }
@@ skipping 1733 matching lines @@
       } else {
         value = new JS.LiteralNull();
       }
       fields[element] = value;
     });
 
     var body = <JS.Statement>[];
     fields.forEach((FieldElement e, JS.Expression initialValue) {
       JS.Expression access =
           _classProperties.virtualFields[e] ?? _declareMemberName(e.getter);
-      body.add(initialValue
-          .toAssignExpression(js.call('this.#', [access]))
-          .toStatement());
+      body.add(js.statement('this.# = #;', [access, initialValue]));
     });
 
     return _statement(body);
   }
 
   FormalParameterList _parametersOf(node) {
     // TODO(jmesserly): clean this up. If we can model ES6 spread/rest args, we
     // could handle argument initializers more consistently in a separate
     // lowering pass.
     if (node is ConstructorDeclaration) return node.parameters;
@@ skipping 88 matching lines @@
       fn = _emitNativeFunctionBody(node);
     } else {
       fn = _emitFunctionBody(node.element, node.parameters, node.body);
     }
 
     return annotate(
         new JS.Method(_declareMemberName(node.element), fn,
             isGetter: node.isGetter,
             isSetter: node.isSetter,
             isStatic: node.isStatic),
-        null, // don't annotate as this breaks stepping for one-line functions.
+        node,
         node.element);
   }
 
   /// Transform the function so the last parameter is always returned.
   ///
   /// This is useful for indexed set methods, which otherwise would not have
   /// the right return value in JS.
   JS.Block _alwaysReturnLastParameter(JS.Block body, JS.Parameter lastParam) {
     JS.Statement blockBody = body;
     if (JS.Return.foundIn(body)) {
@@ skipping 3491 matching lines @@
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }