Cleanup references to the old DDC repo

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 1313 matching lines @@
       // classes and preserve the Dart initialization order.
       //
       // Instead we use the same trick as named constructors, and do them as
       // instance methods that perform initialization.
       //
       // Therefore, dart:core Object gets the one real `constructor` and
       // immediately bounces to the `new() { ... }` initializer, letting us
       // bypass the ES6 restrictions.
       //
       // TODO(jmesserly): we'll need to rethink this.
-      // See <https://github.com/dart-lang/dev_compiler/issues/51>.
+      // See https://github.com/dart-lang/sdk/issues/28322.
       // This level of indirection will hurt performance.
       jsMethods.add(new JS.Method(
           _propertyName('constructor'),
           js.call('function(...args) { return this.new.apply(this, args); }')
               as JS.Fun));
     } else if (ctors.isEmpty) {
       jsMethods.add(_emitImplicitConstructor(node, fields, virtualFields));
     }
 
     bool hasJsPeer = findAnnotation(element, isJsPeerInterface) != null;
@@ skipping 941 matching lines @@
             paramName,
             _defaultParamValue(param),
           ]));
         } else if (param.kind == ParameterKind.POSITIONAL) {
           body.add(js.statement('if (# === void 0) # = #;',
               [jsParam, jsParam, _defaultParamValue(param)]));
         }
       }
 
       // TODO(jmesserly): various problems here, see:
-      // https://github.com/dart-lang/dev_compiler/issues/116
+      // https://github.com/dart-lang/sdk/issues/27259
       var paramType =
           resolutionMap.elementDeclaredByFormalParameter(param).type;
       if (node is MethodDeclaration &&
           (resolutionMap.elementDeclaredByFormalParameter(param).isCovariant ||
               _unsoundCovariant(paramType, true)) &&
           !_inWhitelistCode(node)) {
         var castType = _emitType(paramType,
             nameType: options.nameTypeTests || options.hoistTypeTests,
             hoistType: options.hoistTypeTests);
         body.add(js.statement('#._check(#);', [castType, jsParam]));
@@ skipping 334 matching lines @@
     //   }, T, <args>).bind(this);
     // }
     //
     // We need to include <args> in case any are mutated, so each `.iterator`
     // gets the same initial values.
     //
     // TODO(jmesserly): we could omit the args for the common case where args
     // are not mutated inside the generator.
     //
     // In the future, we might be able to simplify this, see:
-    // https://github.com/dart-lang/dev_compiler/issues/247.
-    //
+    // https://github.com/dart-lang/sdk/issues/28320
     // `async` works the same, but uses the `dart.async` helper.
     //
     // In the body of a `sync*` and `async`, `yield`/`await` are both generated
     // simply as `yield`.
     //
     // `async*` uses the `dart.asyncStar` helper, and also has an extra `stream`
     // argument to the generator, which is used for passing values to the
     // _AsyncStarStreamController implementation type.
     // `yield` is specially generated inside `async*`, see visitYieldStatement.
     // `await` is generated as `yield`.
@@ skipping 286 matching lines @@
           optionalTypes, parameters?.sublist(parameterTypes.length),
           nameType: nameType, hoistType: hoistType);
       typeParts = [rt, ra, oa];
     } else {
       typeParts = [rt, ra];
     }
 
     var typeFormals = type.typeFormals;
     if (typeFormals.isNotEmpty && !lowerTypedef) {
       // TODO(jmesserly): this is a suboptimal representation for universal
-      // function types (as callable functions). See discussion at:
-      // https://github.com/dart-lang/dev_compiler/issues/526
+      // function types (as callable functions). See discussion at
+      // https://github.com/dart-lang/sdk/issues/27333
       var tf = _emitTypeFormals(typeFormals);
       var names = _typeTable.discharge(typeFormals);
       var parts = new JS.ArrayInitializer(typeParts);
       if (names.isEmpty) {
         typeParts = [
           js.call('(#) => #', [tf, parts])
         ];
       } else {
         typeParts = [
           js.call('(#) => {#; return #;}', [tf, names, parts])
@@ skipping 2665 matching lines @@
     }
     var type = functionType.returnType;
 
     InterfaceType expectedType = null;
     if (element.isAsynchronous) {
       if (element.isGenerator) {
         // Stream<T> -> T
         expectedType = types.streamType;
       } else {
         // Future<T> -> T
-        // TODO(vsm): Revisit with issue #228.
         expectedType = types.futureType;
       }
     } else {
       if (element.isGenerator) {
         // Iterable<T> -> T
         expectedType = types.iterableType;
       } else {
         // T -> T
         return type;
       }
@@ skipping 158 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;
 }