anchor.diff:          arguments.positional[positionalIndex++].accept(this);
           builtArguments.add(pop());
         } else {
  -        ConstantValue constantValue = _elementMap.getConstantValue(
  -            member, parameter.initializer,
  -            implicitNull: true);
  -        assert(
  -            constantValue != null,
  -            failedAt(_elementMap.getMethod(function.parent),
  -                'No constant computed for $parameter'));
  -        builtArguments.add(graph.addConstant(constantValue, closedWorld));
  +        builtArguments.add(_defaultValueForParameter(member, parameter));
         }
       });
  +    // Evaluate named arguments in given order.
  +    Map<String, HInstruction> namedArguments = _visitNamedArguments(arguments);
  +    // And add them to `builtArguments` in calling-convention order.
       function.namedParameters.toList()
         ..sort(namedOrdering)
         ..forEach((ir.VariableDeclaration parameter) {
  -        var correspondingNamed = arguments.named.firstWhere(
  -            (named) => named.name == parameter.name,
  -            orElse: () => null);
  -        if (correspondingNamed != null) {
  -          correspondingNamed.value.accept(this);
  -          builtArguments.add(pop());
  -        } else {
  -          ConstantValue constantValue = _elementMap.getConstantValue(
  -              member, parameter.initializer,
  -              implicitNull: true);
  -          assert(
  -              constantValue != null,
  -              failedAt(_elementMap.getMethod(function.parent),
  -                  'No constant computed for $parameter'));
  -          builtArguments.add(graph.addConstant(constantValue, closedWorld));
  -        }
  +        var argument = namedArguments[parameter.name];
  +        argument ??= _defaultValueForParameter(member, parameter);
  +        builtArguments.add(argument);
         });
   
       return builtArguments;
  
positive.code:     List<HInstruction> values = _visitPositionalArguments(arguments);
  
      if (arguments.named.isNotEmpty) {
        Map<String, HInstruction> namedValues = {};
        for (ir.NamedExpression argument in arguments.named) {
          argument.value.accept(this);
          namedValues[argument.name] = pop();
        }
        for (String name in selector.callStructure.getOrderedNamedArguments()) {
          values.add(namedValues[name]);
        }
  
negative.code:     }
    }
  
    /// Generate instructions to evaluate the positional arguments in source
    /// order.
    List<HInstruction> _visitPositionalArguments(ir.Arguments arguments) {
      List<HInstruction> result = [];
      for (ir.Expression argument in arguments.positional) {
  