Merge remote-tracking branch 'upstream/master'

Author: iachievedit

CHANGELOG.md

@@ -2,6 +2,14 @@ Note: This is in reverse chronological order, so newer entries are added to the
 
 Swift 3.0
 ---------
+* [SE-0096](https://github.com/apple/swift-evolution/blob/master/proposals/0096-dynamictype.md):
+
+  The `dynamicType` keyword has been removed from Swift.  In its place a new
+  primitive function `type(of:)` has been added to the language.  Existing code
+  that uses the `.dynamicType` member to retrieve the type of an expression 
+  should migrate to this new primitive.  Code that is using `.dynamicType` in 
+  conjunction with `sizeof` should migrate to the `MemoryLayout` structure provided by
+  [SE-0101](https://github.com/apple/swift-evolution/blob/master/proposals/0101-standardizing-sizeof-naming.md).
 
 * [SE-0111](https://github.com/apple/swift-evolution/blob/master/proposals/0111-remove-arg-label-type-significance.md):
 

docs/GenericsManifesto.md

@@ -120,7 +120,7 @@ in the following ``C.array1`` and ``D.array1`` will be accessed directly
   }
 
   class D {
-    final var array1 [Int] // 'array1' cannot be overridden by a computed property.
+    final var array1: [Int] // 'array1' cannot be overridden by a computed property.
     var array2: [Int]      // 'array2' *can* be overridden by a computed property.
   }
 

docs/OptimizationTips.rst

@@ -1114,7 +1114,7 @@ ERROR(expr_typeof_expected_expr,PointsToFirstBadToken,
       "expected an expression within 'type(of: ...)'", ())
 ERROR(expr_typeof_expected_rparen,PointsToFirstBadToken,
       "expected ')' to complete 'type(of: ...)' expression", ())
-WARNING(expr_dynamictype_deprecated,PointsToFirstBadToken,
+ERROR(expr_dynamictype_deprecated,PointsToFirstBadToken,
       "'.dynamicType' is deprecated. Use 'type(of: ...)' instead", ())
 
 //------------------------------------------------------------------------------

include/swift/AST/DiagnosticsParse.def

@@ -238,7 +238,8 @@ ERROR(cannot_invoke_closure_type,none,
 ERROR(cannot_infer_closure_type,none,
       "unable to infer closure type in the current context", ())
 ERROR(cannot_infer_closure_result_type,none,
-      "unable to infer closure return type in current context", ())
+      "unable to infer complex closure return type; "
+      "add explicit type to disambiguate", ())
 
 ERROR(incorrect_explicit_closure_result,none,
       "declared closure result %0 is incompatible with contextual type %1",

include/swift/AST/DiagnosticsSema.def

@@ -147,9 +147,6 @@ KEYWORD(__COLUMN__)
 KEYWORD(__FUNCTION__)
 KEYWORD(__DSO_HANDLE__)
 
-// FIXME(SE-0096): REMOVE ME
-KEYWORD(dynamicType)
-
 // Pattern keywords.
 KEYWORD(_)
 

include/swift/Parse/Tokens.def

@@ -36,7 +36,6 @@ bool swift::canBeArgumentLabel(StringRef identifier) {
 
 bool swift::canBeMemberName(StringRef identifier) {
   return llvm::StringSwitch<bool>(identifier)
-    .Case("dynamicType", false)
     .Case("init", false)
     .Case("Protocol", false)
     .Case("self", false)

lib/Basic/StringExtras.cpp

@@ -950,6 +950,32 @@ getMagicIdentifierLiteralKind(tok Kind) {
   }
 }
 
+/// See if type(of: <expr>) can be parsed backtracking on failure.
+static bool canParseTypeOf(Parser &P) {
+  if (!(P.Tok.getText() == "type" && P.peekToken().is(tok::l_paren))) {
+    return false;
+  }
+  // Look ahead to parse the parenthesized expression.
+  Parser::BacktrackingScope Backtrack(P);
+  P.consumeToken(tok::identifier);
+  P.consumeToken(tok::l_paren);
+  // The first argument label must be 'of'.
+  if (!(P.Tok.getText() == "of" && P.peekToken().is(tok::colon))) {
+    return false;
+  }
+
+  // Parse to the closing paren.
+  while (!P.Tok.is(tok::r_paren) && !P.Tok.is(tok::eof)) {
+    // Anything that looks like another argument label is bogus.  It is
+    // sufficient to parse for a single trailing comma.  Backtracking will
+    // fall back to an unresolved decl.
+    if (P.Tok.is(tok::comma)) {
+      return false;
+    }
+    P.skipSingle();
+  }
+  return true;
+}
 
 /// parseExprPostfix
 ///
@@ -1095,8 +1121,8 @@ ParserResult<Expr> Parser::parseExprPostfix(Diag<> ID, bool isExprBasic) {
   }
 
   case tok::identifier:  // foo
-    // If starts with 'type(', parse the 'type(of: ...)' metatype expression
-    if (Tok.getText() == "type" && peekToken().is(tok::l_paren)) {
+    // Attempt to parse for 'type(of: <expr>)'.
+    if (canParseTypeOf(*this)) {
       Result = parseExprTypeOf();
       break;
     }
@@ -1418,35 +1444,25 @@ ParserResult<Expr> Parser::parseExprPostfix(Diag<> ID, bool isExprBasic) {
         continue;
       }
 
-      // Handle "x.dynamicType" - A metatype expr.
-      // Deprecated in SE-0096: `x.dynamicType` becomes `type(of: x)`
-      //
-      // FIXME(SE-0096): This will go away along with the keyword soon.
-      if (Tok.is(tok::kw_dynamicType)) {
-        // Fix-it
+      // Handle "x.self" expr.
+      if (Tok.is(tok::kw_self)) {
+        Result = makeParserResult(
+          new (Context) DotSelfExpr(Result.get(), TokLoc, consumeToken()));
+        continue;
+      }
+
+      // Handle the deprecated 'x.dynamicType' and migrate it to `type(of: x)`
+      if (Tok.getText() == "dynamicType") {
+        BacktrackingScope backtrackScope(*this);
         auto range = Result.get()->getSourceRange();
         auto dynamicTypeExprRange = SourceRange(TokLoc, consumeToken());
         diagnose(TokLoc, diag::expr_dynamictype_deprecated)
           .highlight(dynamicTypeExprRange)
           .fixItReplace(dynamicTypeExprRange, ")")
           .fixItInsert(range.Start, "type(of: ");
 
-        // HACK: Arbitrary.
-        auto loc = range.Start;
-        auto dt = new (Context) DynamicTypeExpr(loc, loc, Result.get(), loc, Type());
-        dt->setImplicit();
-        Result = makeParserResult(dt);
-        continue;
+        // fallthrough to an UnresolvedDotExpr.
       }
-
-
-      // Handle "x.self" expr.
-      if (Tok.is(tok::kw_self)) {
-        Result = makeParserResult(
-          new (Context) DotSelfExpr(Result.get(), TokLoc, consumeToken()));
-        continue;
-      }
-      
 
       // If we have '.<keyword><code_complete>', try to recover by creating
       // an identifier with the same spelling as the keyword.
@@ -3030,26 +3046,14 @@ ParserResult<Expr> Parser::parseExprTypeOf() {
   SourceLoc lParenLoc = consumeToken(tok::l_paren);
 
   // Parse `of` label.
-  auto ofRange = Tok.getRange();
-  if (Tok.canBeArgumentLabel() && peekToken().is(tok::colon)) {
-    bool hasOf = Tok.getText() == "of";
-    if (!hasOf) {
-      // User mis-spelled the 'of' label.
-      diagnose(Tok, diag::expr_typeof_expected_label_of)
-        .fixItReplace({ ofRange.getStart(), ofRange.getEnd() }, "of");
-    }
-
-    // Consume either 'of' or the misspelling.
+  if (Tok.getText() == "of" && peekToken().is(tok::colon)) {
+    // Consume the label.
     consumeToken();
     consumeToken(tok::colon);
-
-    if (!hasOf) {
-      return makeParserError();
-    }
   } else {
-    // No label at all; insert it.
-    diagnose(Tok, diag::expr_typeof_expected_label_of)
-      .fixItInsert(ofRange.getStart(), "of: ");
+    // There cannot be a richer diagnostic here because the user may have
+    // defined a function `type(...)` that conflicts with the magic expr.
+    diagnose(Tok, diag::expr_typeof_expected_label_of);
   }
 
   // Parse the subexpression.

lib/Parse/ParseExpr.cpp

@@ -78,7 +78,6 @@ ParserResult<TypeRepr> Parser::parseTypeSimple(Diag<> MessageID,
     consumeToken(tok::code_complete);
     return makeParserCodeCompletionResult<TypeRepr>();
   case tok::kw_super:
-  case tok::kw_dynamicType:
   case tok::kw_self:
     // These keywords don't start a decl or a statement, and thus should be
     // safe to skip over.

lib/Parse/ParseType.cpp

@@ -1240,7 +1240,7 @@ collectClassSelfUses(SILValue ClassPointer, SILType MemorySILType,
       if (isSelfInitUse(VMI))
         Kind = DIUseKind::SelfInit;
       else
-        // Otherwise, this is a simple reference to "dynamicType", which is
+        // Otherwise, this is a simple reference to "type(of:)", which is
         // always fine, even if self is uninitialized.
         continue;
     }
@@ -1386,7 +1386,7 @@ void ElementUseCollector::collectDelegatingClassInitSelfUses() {
           if (isSelfInitUse(VMI))
             Kind = DIUseKind::SelfInit;
           else
-            // Otherwise, this is a simple reference to "dynamicType", which is
+            // Otherwise, this is a simple reference to "type(of:)", which is
             // always fine, even if self is uninitialized.
             continue;
         }