Fix DOM constructors in inline JS

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 3689 matching lines @@
   }
 
   /// Emits code for the `JS(...)` macro.
   _emitForeignJS(MethodInvocation node) {
     var e = node.methodName.staticElement;
     if (isInlineJS(e)) {
       var args = node.argumentList.arguments;
       // arg[0] is static return type, used in `RestrictedStaticTypeAnalyzer`
       var code = args[1];
       List<AstNode> templateArgs;
-      var source;
+      String source;
       if (code is StringInterpolation) {
         if (args.length > 2) {
           throw new ArgumentError(
               "Can't mix template args and string interpolation in JS calls.");
         }
         templateArgs = <Expression>[];
         source = code.elements.map((element) {
           if (element is InterpolationExpression) {
             templateArgs.add(element.expression);
             return '#';
           } else {
             return (element as InterpolationString).value;
           }
         }).join();
       } else {
         templateArgs = args.skip(2).toList();
         source = (code as StringLiteral).stringValue;
       }
 
+      // TODO(vsm): Constructors in dart:html and friends are trying to
+      // allocate a type defined on window/self, but this often conflicts a
+      // with the generated extenstion class in scope.  We really should
+      // qualify explicitly in dart:html itself.
+      var constructorPattern = new RegExp("new [A-Z][A-Za-z]+\\(");
+      if (constructorPattern.matchAsPrefix(source) != null) {
+        var containingClass = node.parent;
+        while (
+            containingClass != null && containingClass is! ClassDeclaration) {
+          containingClass = containingClass.parent;
+        }
+        if (containingClass is ClassDeclaration &&
+            _extensionTypes.isNativeClass(containingClass.element)) {
+          var constructorName = source.substring(4, source.indexOf('('));
+          var className = containingClass.name.name;
+          if (className == constructorName) {
+            source =
+                source.replaceFirst('new $className(', 'new self.$className(');
+          }
+        }
+      }
+
       // TODO(rnystrom): The JS() calls are almost never nested, and probably
       // really shouldn't be, but there are at least a couple of calls in the
       // HTML library where an argument to JS() is itself a JS() call. If those
       // go away, this can just assert(!_isInForeignJS).
       // Inside JS(), type names evaluate to the raw runtime type, not the
       // wrapped Type object.
       var wasInForeignJS = _isInForeignJS;
       _isInForeignJS = true;
 
       var template = js.parseForeignJS(source);
@@ skipping 2128 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;
 }