fix list_test for strong mode, and fix DDC List constructors

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 132 matching lines @@
 
   final ClassElement boolClass;
   final ClassElement intClass;
   final ClassElement interceptorClass;
   final ClassElement nullClass;
   final ClassElement numClass;
   final ClassElement objectClass;
   final ClassElement stringClass;
   final ClassElement functionClass;
   final ClassElement privateSymbolClass;
+  final PropertyAccessorElement _undefinedConstant;
 
   ConstFieldVisitor _constants;
 
   /// The current function body being compiled.
   FunctionBody _currentFunction;
 
   HashMap<TypeDefiningElement, AstNode> _declarationNodes;
 
   /// The stack of currently emitting elements, if generating top-level code
   /// for them. This is not used when inside method bodies, because order does
@@ skipping 53 matching lines @@
         dartCoreLibrary = _getLibrary(c, 'dart:core'),
         boolClass = _getLibrary(c, 'dart:core').getType('bool'),
         intClass = _getLibrary(c, 'dart:core').getType('int'),
         numClass = _getLibrary(c, 'dart:core').getType('num'),
         nullClass = _getLibrary(c, 'dart:core').getType('Null'),
         objectClass = _getLibrary(c, 'dart:core').getType('Object'),
         stringClass = _getLibrary(c, 'dart:core').getType('String'),
         functionClass = _getLibrary(c, 'dart:core').getType('Function'),
         privateSymbolClass =
             _getLibrary(c, 'dart:_internal').getType('PrivateSymbol'),
-        dartJSLibrary = _getLibrary(c, 'dart:js') {
+        dartJSLibrary = _getLibrary(c, 'dart:js'),
+        _undefinedConstant =
+            _getLibrary(c, 'dart:_runtime').publicNamespace.get('undefined') {
+    assert(_undefinedConstant != null);
     typeRep = new JSTypeRep(rules, types);
   }
 
   Element get currentElement => _currentElements.last;
 
   LibraryElement get currentLibrary => currentElement.library;
 
   /// The main entry point to JavaScript code generation.
   ///
   /// Takes the metadata for the build unit, as well as resolved trees and
@@ skipping 349 matching lines @@
     // 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);
     List<VariableDeclaration> fields;
     for (var declaration in unit.declarations) {
       if (declaration is TopLevelVariableDeclaration) {
         inferNullableTypes(declaration);
-        if (isInternalSdk && declaration.variables.isFinal) {
+        if (isInternalSdk &&
+            (declaration.variables.isFinal || declaration.variables.isConst)) {
           _emitInternalSdkFields(declaration.variables.variables);
         } else {
           (fields ??= []).addAll(declaration.variables.variables);
         }
         continue;
       }
 
       if (fields != null) {
         _emitTopLevelFields(fields);
         fields = null;
@@ skipping 1797 matching lines @@
     // than always when we visit the function body, so we control it explicitly.
     if (node is ConstructorDeclaration != constructor) return null;
 
     var parameters = _parametersOf(node);
     if (parameters == null) return null;
 
     var body = <JS.Statement>[];
     for (var param in parameters.parameters) {
       var jsParam = _emitSimpleIdentifier(param.identifier);
 
-      if (!options.destructureNamedParams) {
+      if (!options.destructureNamedParams &&
+          param.kind != ParameterKind.REQUIRED) {
         if (param.kind == ParameterKind.NAMED) {
           // Parameters will be passed using their real names, not the (possibly
           // renamed) local variable.
           var paramName = js.string(param.identifier.name, "'");
-
-          // TODO(ochafik): Fix `'prop' in obj` to please Closure's renaming.
-          body.add(js.statement('let # = # && # in # ? #.# : #;', [
-            jsParam,
-            namedArgumentTemp,
-            paramName,
-            namedArgumentTemp,
-            namedArgumentTemp,
-            paramName,
-            _defaultParamValue(param),
-          ]));
+          var defaultValue = _defaultParamValue(param);
+          if (defaultValue != null) {
+            // TODO(ochafik): Fix `'prop' in obj` to please Closure's renaming.
+            body.add(js.statement('let # = # && # in # ? #.# : #;', [
+              jsParam,
+              namedArgumentTemp,
+              paramName,
+              namedArgumentTemp,
+              namedArgumentTemp,
+              paramName,
+              defaultValue,
+            ]));
+          } else {
+            body.add(js.statement('let # = # && #.#;', [
+              jsParam,
+              namedArgumentTemp,
+              namedArgumentTemp,
+              paramName,
+            ]));
+          }
         } else if (param.kind == ParameterKind.POSITIONAL) {
-          body.add(js.statement('if (# === void 0) # = #;',
-              [jsParam, jsParam, _defaultParamValue(param)]));
+          var defaultValue = _defaultParamValue(param);
+          if (defaultValue != null) {
+            body.add(js.statement(
+                'if (# === void 0) # = #;', [jsParam, jsParam, defaultValue]));
+          }
         }
       }
 
       var paramElement = resolutionMap.elementDeclaredByFormalParameter(param);
       if (_isCovariant(paramElement)) {
         var castType = _emitType(paramElement.type);
         body.add(js.statement('#._check(#);', [castType, jsParam]));
       }
       if (_annotatedNullCheck(paramElement)) {
         body.add(nullParameterCheck(jsParam));
       }
     }
     return body.isEmpty ? null : _statement(body);
   }
 
   bool _isCovariant(ParameterElement p) {
     if (p.isCovariant) return true;
     var covariantParams = _classProperties?.covariantParameters;
     return covariantParams != null && covariantParams.contains(p);
   }
 
   JS.Expression _defaultParamValue(FormalParameter param) {
     if (param is DefaultFormalParameter && param.defaultValue != null) {
+      var defaultValue = param.defaultValue;
+      if (defaultValue is Identifier &&
+          defaultValue.staticElement == _undefinedConstant) {
+        return null;
+      }
       return _visit(param.defaultValue);
     } else {
       return new JS.LiteralNull();
     }
   }
 
   JS.Fun _emitNativeFunctionBody(MethodDeclaration node) {
     String name =
         getAnnotationName(node.element, isJSAnnotation) ?? node.name.name;
     if (node.isGetter) {
@@ skipping 1446 matching lines @@
           }
           JS.Expression name;
           JS.SimpleBindingPattern structure = null;
           String paramName = param.identifier.name;
           if (JS.invalidVariableName(paramName)) {
             name = js.string(paramName);
             structure = new JS.SimpleBindingPattern(_visit(param.identifier));
           } else {
             name = _visit(param.identifier);
           }
+
+          var defaultValue = _defaultParamValue(param);
           namedVars.add(new JS.DestructuredVariable(
-              name: name,
-              structure: structure,
-              defaultValue: _defaultParamValue(param)));
+              name: name, structure: structure, defaultValue: defaultValue));
         } else {
           needsOpts = true;
         }
       } else {
         var jsParam = _visit(param);
-        result.add(param is DefaultFormalParameter && destructure
+        var defaultValue = _defaultParamValue(param);
+        result.add(destructure && defaultValue != null
             ? new JS.DestructuredVariable(
-                name: jsParam, defaultValue: _defaultParamValue(param))
+                name: jsParam, defaultValue: defaultValue)
             : jsParam);
       }
     }
 
     if (needsOpts) {
       result.add(namedArgumentTemp);
     } else if (namedVars.isNotEmpty) {
       // Note: `var {valueOf} = {}` extracts `Object.prototype.valueOf`, so
       // in case there are conflicting names we create an object without
       // any prototype.
@@ skipping 87 matching lines @@
     // A normal yield in a sync*
     return jsExpr.toYieldStatement(star: star);
   }
 
   @override
   JS.Expression visitAwaitExpression(AwaitExpression node) {
     return new JS.Yield(_visit(node.expression));
   }
 
   /// This is not used--we emit top-level fields as we are emitting the
-  /// compilation unit, see [_emitCompilationUnit].
+  /// compilation unit, see [visitCompilationUnit].
   @override
   visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     assert(false);
   }
 
   /// This is not used--we emit fields as we are emitting the class,
   /// see [visitClassDeclaration].
   @override
   visitFieldDeclaration(FieldDeclaration node) {
     assert(false);
@@ skipping 40 matching lines @@
 
   /// Emits a list of top-level field.
   void _emitTopLevelFields(List<VariableDeclaration> fields) {
     _moduleItems.add(_emitLazyFields(currentLibrary, fields));
   }
 
   /// Treat dart:_runtime fields as safe to eagerly evaluate.
   // TODO(jmesserly): it'd be nice to avoid this special case.
   void _emitInternalSdkFields(List<VariableDeclaration> fields) {
     for (var field in fields) {
+      // Skip our magic undefined constant.
+      var element = field.element as TopLevelVariableElement;
+      if (element.getter == _undefinedConstant) continue;
       _moduleItems.add(annotate(
           js.statement('# = #;',
               [_emitTopLevelName(field.element), _visitInitializer(field)]),
           field,
           field.element));
     }
   }
 
   JS.Expression _visitInitializer(VariableDeclaration node) {
     var value = _annotatedNullCheck(node.element)
@@ skipping 1925 matching lines @@
   // 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;
 }
 
 bool _annotatedNullCheck(Element e) =>
     e != null && findAnnotation(e, isNullCheckAnnotation) != null;