Emit a compile-time error when a named optional parameter has a library private name.

sdk/lib/_internal/compiler/implementation/resolution/members.dart

 // Copyright (c) 2012, 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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Set<Node> get superUses;
 
@@ skipping 3984 matching lines @@
 }
 
 /**
  * [SignatureResolver] resolves function signatures.
  */
 class SignatureResolver extends CommonResolverVisitor<Element> {
   final Element enclosingElement;
   final bool defaultValuesAllowed;
   Link<Element> optionalParameters = const Link<Element>();
   int optionalParameterCount = 0;
+  bool isOptionalParameter = false;
   bool optionalParametersAreNamed = false;
   VariableDefinitions currentDefinitions;
 
   SignatureResolver(Compiler compiler,
                     this.enclosingElement,
                     {this.defaultValuesAllowed: true})
       : super(compiler);
 
   Element visitNodeList(NodeList node) {
     // This must be a list of optional arguments.
     String value = node.beginToken.stringValue;
     if ((!identical(value, '[')) && (!identical(value, '{'))) {
       internalError(node, "expected optional parameters");
     }
     optionalParametersAreNamed = (identical(value, '{'));
+    isOptionalParameter = true;
     LinkBuilder<Element> elements = analyzeNodes(node.nodes);
     optionalParameterCount = elements.length;
     optionalParameters = elements.toLink();
     return null;
   }
 
   Element visitVariableDefinitions(VariableDefinitions node) {
     Link<Node> definitions = node.definitions.nodes;
     if (definitions.isEmpty) {
       cancel(node, 'internal error: no parameter definition');
@@ skipping 16 matching lines @@
 
     if (currentDefinitions != null) {
       cancel(node, 'function type parameters not supported');
     }
     currentDefinitions = node;
     Element element = definition.accept(this);
     currentDefinitions = null;
     return element;
   }
 
+  void validateName(Identifier node) {
+    SourceString name = node.source;
+    if (isOptionalParameter &&
+        optionalParametersAreNamed &&
+        node.source.isPrivate()) {
+      compiler.reportError(node, MessageKind.PRIVATE_NAMED_PARAMETER);
+    }
+  }
+
   Element visitIdentifier(Identifier node) {
+    validateName(node);
     Element variables = new VariableListElementX.node(currentDefinitions,
         ElementKind.VARIABLE_LIST, enclosingElement);
     // Ensure a parameter is not typed 'void'.
     variables.computeType(compiler);
     return new VariableElementX(node.source, variables,
         ElementKind.PARAMETER, node);
   }
 
   SourceString getParameterName(Send node) {
     var identifier = node.selector.asIdentifier();
     if (identifier != null) {
       // Normal parameter: [:Type name:].
+      validateName(identifier);
       return identifier.source;
     } else {
       // Function type parameter: [:void name(DartType arg):].
       var functionExpression = node.selector.asFunctionExpression();
       if (functionExpression != null &&
           functionExpression.name.asIdentifier() != null) {
+        validateName(functionExpression.name);
         return functionExpression.name.asIdentifier().source;
       } else {
         cancel(node,
             'internal error: unimplemented receiver on parameter send');
       }
     }
   }
 
   // The only valid [Send] can be in constructors and must be of the form
   // [:this.x:] (where [:x:] represents an instance field).
@@ skipping 23 matching lines @@
 
   /// A [SendSet] node is an optional parameter with a default value.
   Element visitSendSet(SendSet node) {
     Element element;
     if (node.receiver != null) {
       element = visitSend(node);
     } else if (node.selector.asIdentifier() != null ||
                node.selector.asFunctionExpression() != null) {
       Element variables = new VariableListElementX.node(currentDefinitions,
           ElementKind.VARIABLE_LIST, enclosingElement);
-      SourceString source = node.selector.asIdentifier() != null ?
-          node.selector.asIdentifier().source :
-          node.selector.asFunctionExpression().name.asIdentifier().source;
+      Identifier identifier = node.selector.asIdentifier() != null ?
+          node.selector.asIdentifier() :
+          node.selector.asFunctionExpression().name.asIdentifier();
+      validateName(identifier);
+      SourceString source = identifier.source;
       element = new VariableElementX(source, variables,
           ElementKind.PARAMETER, node);
     }
     Node defaultValue = node.arguments.head;
     if (!defaultValuesAllowed) {
       error(defaultValue, MessageKind.TYPEDEF_FORMAL_WITH_DEFAULT);
     }
     // Visit the value. The compile time constant handler will
     // make sure it's a compile time constant.
     resolveExpression(defaultValue);
@@ skipping 264 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }