---

yaml
---
r: 348915
b: refs/heads/master
c: 43df5a2
h: refs/heads/master
i:
  348913: ef3f671
  348911: 2ad9bae

Author: rintaro

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: bc1a3eaaa5b213fd0f8d5679ac1f905208c44e83
+refs/heads/master: 43df5a240e3f08daf8d7c0c78de676d6c8827d11
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/include/swift/AST/DiagnosticsSema.def

@@ -3493,8 +3493,6 @@ ERROR(single_tuple_parameter_mismatch_special,none,
 ERROR(single_tuple_parameter_mismatch_normal,none,
       "%0 %1 expects a single parameter of type %2%3",
       (DescriptiveDeclKind, DeclBaseName, Type, StringRef))
-NOTE(note_maybe_forgot_to_form_tuple,none,
-     "did you mean to pass a tuple?", ())
 ERROR(unknown_single_tuple_parameter_mismatch,none,
       "single parameter of type %0 is expected in call", (Type))
 ERROR(cannot_convert_single_tuple_into_multiple_arguments,none,

trunk/include/swift/Parse/ASTGen.h

@@ -81,6 +81,7 @@ class ASTGen {
 
   Expr *generate(const syntax::ExprSyntax &Expr, const SourceLoc Loc);
   Expr *generate(const syntax::IdentifierExprSyntax &Expr, const SourceLoc Loc);
+  Expr *generate(const syntax::SuperRefExprSyntax &Expr, const SourceLoc Loc);
   Expr *generate(const syntax::EditorPlaceholderExprSyntax &Expr,
                  const SourceLoc Loc);
   Expr *generate(const syntax::SpecializeExprSyntax &Expr, const SourceLoc Loc);

trunk/include/swift/Parse/Parser.h

@@ -1454,6 +1454,7 @@ class Parser {
   ParserResult<Expr> parseExprKeyPath();
   ParserResult<Expr> parseExprSelector();
   ParserResult<Expr> parseExprSuper();
+  ParsedSyntaxResult<ParsedExprSyntax> parseExprSuperSyntax();
   ParserResult<Expr> parseExprStringLiteral();
 
   // todo [gsoc]: create new result type for ParsedSyntax

trunk/lib/Parse/ASTGen.cpp

@@ -234,6 +234,8 @@ Expr *ASTGen::generate(const ExprSyntax &E, const SourceLoc Loc) {
 
   if (auto identifierExpr = E.getAs<IdentifierExprSyntax>())
     result = generate(*identifierExpr, Loc);
+  else if (auto superRefExpr = E.getAs<SuperRefExprSyntax>())
+    result = generate(*superRefExpr, Loc);
   else if (auto specializeExpr = E.getAs<SpecializeExprSyntax>())
     result = generate(*specializeExpr, Loc);
   else if (auto editorPlaceHolderExpr = E.getAs<EditorPlaceholderExprSyntax>())
@@ -256,8 +258,14 @@ Expr *ASTGen::generate(const ExprSyntax &E, const SourceLoc Loc) {
     result = generate(*poundFunctionExpr, Loc);
   else if (auto poundDsohandleExpr = E.getAs<PoundDsohandleExprSyntax>())
     result = generate(*poundDsohandleExpr, Loc);
-  else
+  else if (auto unknownExpr = E.getAs<UnknownExprSyntax>())
+    result = generate(*unknownExpr, Loc);
+  else {
+#ifndef NDEBUG
+    E.dump();
     llvm_unreachable("unsupported expression");
+#endif
+  }
 
   return result;
 }
@@ -366,6 +374,39 @@ Expr *ASTGen::generate(const IdentifierExprSyntax &E, const SourceLoc Loc) {
   return new (Context) DeclRefExpr(D, nameLoc, /*implicit=*/false);
 }
 
+static VarDecl *getImplicitSelfDeclForSuperContext(Parser &P,
+                                                   DeclContext *DC,
+                                                   SourceLoc Loc) {
+  auto *methodContext = DC->getInnermostMethodContext();
+  if (!methodContext) {
+    P.diagnose(Loc, diag::super_not_in_class_method);
+    return nullptr;
+  }
+
+  // Do an actual lookup for 'self' in case it shows up in a capture list.
+  auto *methodSelf = methodContext->getImplicitSelfDecl();
+  auto *lookupSelf = P.lookupInScope(P.Context.Id_self);
+  if (lookupSelf && lookupSelf != methodSelf) {
+    // FIXME: This is the wrong diagnostic for if someone manually declares a
+    // variable named 'self' using backticks.
+    P.diagnose(Loc, diag::super_in_closure_with_capture);
+    P.diagnose(lookupSelf->getLoc(), diag::super_in_closure_with_capture_here);
+    return nullptr;
+  }
+
+  return methodSelf;
+}
+
+Expr *ASTGen::generate(const SuperRefExprSyntax &E, const SourceLoc Loc) {
+  auto superLoc = advanceLocBegin(Loc, E.getSuperKeyword());
+  VarDecl *selfDecl =
+      getImplicitSelfDeclForSuperContext(P, P.CurDeclContext, superLoc);
+  if (!selfDecl)
+    return new (Context) ErrorExpr(superLoc);
+
+  return new (Context) SuperRefExpr(selfDecl, superLoc, /*Implicit=*/false);
+}
+
 Expr *ASTGen::generate(const EditorPlaceholderExprSyntax &E, const SourceLoc Loc) {
   assert(!E.getIdentifier().isMissing());
 

trunk/lib/Parse/ParseExpr.cpp

@@ -813,29 +813,6 @@ UnresolvedDeclRefExpr *Parser::parseExprOperator() {
   return new (Context) UnresolvedDeclRefExpr(name, refKind, DeclNameLoc(loc));
 }
 
-static VarDecl *getImplicitSelfDeclForSuperContext(Parser &P,
-                                                   DeclContext *DC,
-                                                   SourceLoc Loc) {
-  auto *methodContext = DC->getInnermostMethodContext();
-  if (!methodContext) {
-    P.diagnose(Loc, diag::super_not_in_class_method);
-    return nullptr;
-  }
-
-  // Do an actual lookup for 'self' in case it shows up in a capture list.
-  auto *methodSelf = methodContext->getImplicitSelfDecl();
-  auto *lookupSelf = P.lookupInScope(P.Context.Id_self);
-  if (lookupSelf && lookupSelf != methodSelf) {
-    // FIXME: This is the wrong diagnostic for if someone manually declares a
-    // variable named 'self' using backticks.
-    P.diagnose(Loc, diag::super_in_closure_with_capture);
-    P.diagnose(lookupSelf->getLoc(), diag::super_in_closure_with_capture_here);
-    return nullptr;
-  }
-
-  return methodSelf;
-}
-
 /// parseExprSuper
 ///
 ///   expr-super:
@@ -848,28 +825,36 @@ static VarDecl *getImplicitSelfDeclForSuperContext(Parser &P,
 ///     'super' '.' 'init'
 ///   expr-super-subscript:
 ///     'super' '[' expr ']'
-ParserResult<Expr> Parser::parseExprSuper() {
-  SyntaxParsingContext SuperCtxt(SyntaxContext, SyntaxContextKind::Expr);
-  // Parse the 'super' reference.
-  SourceLoc superLoc = consumeToken(tok::kw_super);
-  SyntaxContext->createNodeInPlace(SyntaxKind::SuperRefExpr);
+ParsedSyntaxResult<ParsedExprSyntax> Parser::parseExprSuperSyntax() {
+  auto superTok = consumeTokenSyntax(tok::kw_super);
 
   // 'super.' must be followed by a member ref, explicit initializer ref, or
   // subscript call.
   if (!Tok.isAny(tok::period, tok::period_prefix, tok::code_complete) &&
       !Tok.isFollowingLSquare()) {
-    if (!consumeIf(tok::unknown))
+    SmallVector<ParsedSyntax, 2> junk;
+    junk.emplace_back(std::move(superTok));
+    if (auto unknown = consumeTokenSyntaxIf(tok::unknown)) {
+      junk.emplace_back(std::move(*unknown));
+    } else {
       diagnose(Tok, diag::expected_dot_or_subscript_after_super);
-    return nullptr;
+    }
+
+    return makeParsedError(
+        ParsedSyntaxRecorder::makeUnknownExpr(junk, *SyntaxContext));
   }
 
-  VarDecl *selfDecl =
-      getImplicitSelfDeclForSuperContext(*this, CurDeclContext, superLoc);
-  if (!selfDecl)
-    return makeParserResult(new (Context) ErrorExpr(superLoc));
+  return makeParsedResult(ParsedSyntaxRecorder::makeSuperRefExpr(
+      std::move(superTok), *SyntaxContext));
+}
 
-  return makeParserResult(new (Context) SuperRefExpr(selfDecl, superLoc,
-                                                     /*Implicit=*/false));
+ParserResult<Expr> Parser::parseExprSuper() {
+  auto leadingLoc = leadingTriviaLoc();
+  auto parsed = parseExprSuperSyntax();
+  SyntaxContext->addSyntax(parsed.get());
+  auto syntax = SyntaxContext->topNode<ExprSyntax>();
+  auto expr = Generator.generate(syntax, leadingLoc);
+  return makeParserResult(parsed.getStatus(), expr);
 }
 
 StringRef Parser::copyAndStripUnderscores(StringRef orig) {

trunk/lib/SILGen/SILGenType.cpp

@@ -153,8 +153,7 @@ SILGenModule::emitVTableMethod(ClassDecl *theClass,
   auto thunk = builder.createFunction(
       SILLinkage::Private, name, overrideInfo.SILFnType,
       cast<AbstractFunctionDecl>(derivedDecl)->getGenericEnvironment(), loc,
-      IsBare, IsNotTransparent, IsNotSerialized, IsNotDynamic,
-      ProfileCounter(), IsThunk);
+      IsBare, IsNotTransparent, IsNotSerialized, IsNotDynamic);
   thunk->setDebugScope(new (M) SILDebugScope(loc, thunk));
 
   PrettyStackTraceSILFunction trace("generating vtable thunk", thunk);

trunk/lib/Sema/CSDiagnostics.cpp

@@ -4880,49 +4880,13 @@ bool InvalidTupleSplatWithSingleParameterFailure::diagnoseAsError() {
           ? emitDiagnostic(argExpr->getLoc(),
                            diag::single_tuple_parameter_mismatch_special,
                            choice->getDescriptiveKind(), paramTy, subsStr)
-          : emitDiagnostic(argExpr->getLoc(),
-                           diag::single_tuple_parameter_mismatch_normal,
-                           choice->getDescriptiveKind(), name, paramTy, subsStr);
-
-
-  auto newLeftParenLoc = argExpr->getStartLoc();
-  if (auto *TE = dyn_cast<TupleExpr>(argExpr)) {
-    auto firstArgLabel = TE->getElementName(0);
-    // Cover situations like:
-    //
-    // func foo(x: (Int, Int)) {}
-    // foo(x: 0, 1)
-    //
-    // Where left paren should be suggested after the label,
-    // since the label belongs to the parameter itself.
-    if (!firstArgLabel.empty()) {
-      auto paramTuple = resolveType(ParamType)->castTo<TupleType>();
-      // If the label of the first argument matches the one required
-      // by the parameter it would be omitted from the fixed parameter type.
-      if (!paramTuple->getElement(0).hasName())
-        newLeftParenLoc = Lexer::getLocForEndOfToken(getASTContext().SourceMgr,
-                                                     TE->getElementNameLoc(0));
-    }
-  }
-
-  // If the parameter is a generic parameter, it's hard to say
-  // whether use of a tuple is really intended here, so let's
-  // attach a fix-it to a note instead of the diagnostic message
-  // to indicate that it's not the only right solution possible.
-  if (auto *typeVar = ParamType->getAs<TypeVariableType>()) {
-    if (typeVar->getImpl().getGenericParameter()) {
-      diagnostic.flush();
-
-      emitDiagnostic(argExpr->getLoc(), diag::note_maybe_forgot_to_form_tuple)
-          .fixItInsertAfter(newLeftParenLoc, "(")
-          .fixItInsert(argExpr->getEndLoc(), ")");
-    }
-  } else {
-    diagnostic.highlight(argExpr->getSourceRange())
-        .fixItInsertAfter(newLeftParenLoc, "(")
-        .fixItInsert(argExpr->getEndLoc(), ")");
-  }
+          : emitDiagnostic(
+                argExpr->getLoc(), diag::single_tuple_parameter_mismatch_normal,
+                choice->getDescriptiveKind(), name, paramTy, subsStr);
 
+  diagnostic.highlight(argExpr->getSourceRange())
+      .fixItInsertAfter(argExpr->getStartLoc(), "(")
+      .fixItInsert(argExpr->getEndLoc(), ")");
   return true;
 }
 

trunk/lib/Sema/CSFix.cpp

@@ -707,42 +707,14 @@ bool AllowTupleSplatForSingleParameter::attempt(
 
   const auto &param = params.front();
 
-  if (param.isInOut() || param.isVariadic() || param.isAutoClosure())
-    return true;
-
-  auto paramTy = param.getOldType();
-
-  // Parameter type has to be either a tuple (with the same arity as
-  // argument list), or a type variable.
-  if (!(paramTy->is<TupleType>() &&
-        paramTy->castTo<TupleType>()->getNumElements() == args.size()) &&
-      !paramTy->is<TypeVariableType>())
+  auto *paramTy = param.getOldType()->getAs<TupleType>();
+  if (!paramTy || paramTy->getNumElements() != args.size())
     return true;
 
   SmallVector<TupleTypeElt, 4> argElts;
-
-  for (unsigned index : indices(args)) {
-    const auto &arg = args[index];
-
-    auto label = arg.getLabel();
-    auto flags = arg.getParameterFlags();
-
-    // In situations where there is a single labeled parameter
-    // we need to form a tuple with omits first label e.g.
-    //
-    // func foo<T>(x: T) {}
-    // foo(x: 0, 1)
-    //
-    // We'd want to suggest argument list to be `x: (0, 1)` instead
-    // of `(x: 0, 1)` which would be incorrect.
-    if (index == 0 && param.getLabel() == label)
-      label = Identifier();
-
-    // Tuple can't have `inout` elements.
-    if (flags.isInOut())
-      return true;
-
-    argElts.push_back({arg.getPlainType(), label});
+  for (const auto &arg : args) {
+    argElts.push_back(
+        {arg.getPlainType(), arg.getLabel(), arg.getParameterFlags()});
   }
 
   bindings[0].clear();

trunk/test/Constraints/enum_cases.swift

@@ -104,8 +104,7 @@ enum E_32551313<L, R> {
 
 struct Foo_32551313 {
   static func bar() -> E_32551313<(String, Foo_32551313?), (String, String)>? {
-    return E_32551313.Left("", Foo_32551313()) // expected-error {{enum case 'Left' expects a single parameter of type 'L' [with L = (String, Foo_32551313?)]}}
-    // expected-note@-1 {{did you mean to pass a tuple?}} {{28-28=(}} {{46-46=)}}
+    return E_32551313.Left("", Foo_32551313()) // expected-error {{extra argument in call}}
   }
 }