[SE-0096] Implement type(of:)

benchmark/single-source/DictionaryBridge.swift

@@ -19,7 +19,7 @@ import TestsUtils
 class Thing : NSObject {
 
   required override init() {
-    let c = self.dynamicType.col()
+    let c = type(of: self).col()
     CheckResults(c!.count == 10, "The rules of the universe apply")
   }
 

docs/archive/LangRef.html

@@ -1255,7 +1255,7 @@ <h3 id="type-metatype">Metatype Types</h3>
     type-metatype ::= type-simple '.' 'Type'
   </pre>
 
-  <p>Every type has an associated metatype <tt>T.dynamicType</tt>.  A value of the metatype
+<p>Every type has an associated metatype <tt>type(of: T)</tt>.  A value of the metatype
     type is a reference to a global object which describes the type.
     Most metatype types are singleton and therefore require no
     storage, but metatypes associated with <a href="#decl-class">class

include/swift/AST/DiagnosticsParse.def

@@ -1105,6 +1105,18 @@ ERROR(expr_selector_expected_property_expr,PointsToFirstBadToken,
 ERROR(expr_selector_expected_rparen,PointsToFirstBadToken,
       "expected ')' to complete '#selector' expression", ())
 
+// Type-of expressions.
+ERROR(expr_typeof_expected_lparen,PointsToFirstBadToken,
+      "expected '(' following 'type'", ())
+ERROR(expr_typeof_expected_label_of,PointsToFirstBadToken,
+      "expected argument label 'of:' within 'type(...)'", ())
+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,
+      "'.dynamicType' is deprecated. Use 'type(of: ...)' instead", ())
+
 //------------------------------------------------------------------------------
 // Attribute-parsing diagnostics
 //------------------------------------------------------------------------------

include/swift/AST/DiagnosticsSema.def

@@ -691,7 +691,7 @@ ERROR(did_not_call_method,none,
       (Identifier))
 
 ERROR(init_not_instance_member,none,
-      "'init' is a member of the type; insert '.dynamicType' to initialize "
+      "'init' is a member of the type; use 'type(of: ...)' to initialize "
       "a new object of the same dynamic type", ())
 ERROR(super_initializer_not_in_initializer,none,
       "'super.init' cannot be called outside of an initializer", ())
@@ -2271,8 +2271,6 @@ WARNING(optional_pattern_match_promotion,none,
         (Type, Type))
 
 
-ERROR(type_of_metatype,none,
-      "'.dynamicType' is not allowed after a type name", ())
 ERROR(invalid_noescape_use,none,
       "non-escaping %select{value|parameter}1 %0 may only be called",
       (Identifier, bool))

include/swift/AST/Expr.h

@@ -3517,30 +3517,36 @@ class AutoClosureExpr : public AbstractClosureExpr {
   }
 };
 
-/// DynamicTypeExpr - "base.dynamicType" - Produces a metatype value.
+/// DynamicTypeExpr - "type(of: base)" - Produces a metatype value.
 ///
-/// The metatype value can comes from evaluating an expression and then
-/// getting its metatype.
+/// The metatype value comes from evaluating an expression then retrieving the
+/// metatype of the result.
 class DynamicTypeExpr : public Expr {
+  SourceLoc KeywordLoc;
+  SourceLoc LParenLoc;
   Expr *Base;
-  SourceLoc MetatypeLoc;
+  SourceLoc RParenLoc;
 
 public:
-  explicit DynamicTypeExpr(Expr *Base, SourceLoc MetatypeLoc, Type Ty)
+  explicit DynamicTypeExpr(SourceLoc KeywordLoc, SourceLoc LParenLoc,
+                           Expr *Base, SourceLoc RParenLoc, Type Ty)
     : Expr(ExprKind::DynamicType, /*Implicit=*/false, Ty),
-      Base(Base), MetatypeLoc(MetatypeLoc) { }
+      KeywordLoc(KeywordLoc), LParenLoc(LParenLoc), Base(Base),
+      RParenLoc(RParenLoc) { }
 
   Expr *getBase() const { return Base; }
   void setBase(Expr *base) { Base = base; }
 
-  SourceLoc getLoc() const { return MetatypeLoc; }
-  SourceLoc getMetatypeLoc() const { return MetatypeLoc; }
-
+  SourceLoc getLoc() const { return KeywordLoc; }
+  SourceRange getSourceRange() const {
+    return SourceRange(KeywordLoc, RParenLoc);
+  }
+
   SourceLoc getStartLoc() const {
-    return getBase()->getStartLoc();
+    return KeywordLoc;
   }
   SourceLoc getEndLoc() const {
-    return (MetatypeLoc.isValid() ? MetatypeLoc : getBase()->getEndLoc());
+    return RParenLoc;
   }
 
   static bool classof(const Expr *E) {

include/swift/Parse/Parser.h

@@ -1118,6 +1118,7 @@ class Parser {
   ParserResult<Expr> parseExprSuper(bool isExprBasic);
   ParserResult<Expr> parseExprConfiguration();
   ParserResult<Expr> parseExprStringLiteral();
+  ParserResult<Expr> parseExprTypeOf();
 
   /// If the token is an escaped identifier being used as an argument
   /// label, but doesn't need to be, diagnose it.

include/swift/Parse/Tokens.def

@@ -130,7 +130,6 @@ STMT_KEYWORD(catch)
 // Expression keywords.
 KEYWORD(as)
 KEYWORD(Any)
-KEYWORD(dynamicType)
 KEYWORD(false)
 KEYWORD(is)
 KEYWORD(nil)
@@ -148,6 +147,9 @@ KEYWORD(__COLUMN__)
 KEYWORD(__FUNCTION__)
 KEYWORD(__DSO_HANDLE__)
 
+// FIXME(SE-0096): REMOVE ME
+KEYWORD(dynamicType)
+
 // Pattern keywords.
 KEYWORD(_)
 

lib/FrontendTool/FrontendTool.cpp

@@ -585,7 +585,7 @@ class JSONFixitWriter : public DiagnosticConsumer {
         Info.ID == diag::invalid_ibinspectable.ID ||
         Info.ID == diag::invalid_ibaction_decl.ID)
       return false;
-    // Adding .dynamicType interacts poorly with the swift migrator by
+    // Adding type(of:) interacts poorly with the swift migrator by
     // invalidating some inits with type errors.
     if (Info.ID == diag::init_not_instance_member.ID)
       return false;

lib/Parse/ParseExpr.cpp

@@ -1095,6 +1095,12 @@ 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)) {
+      Result = parseExprTypeOf();
+      break;
+    }
+
     // If we are parsing a refutable pattern and are inside a let/var pattern,
     // the identifiers change to be value bindings instead of decl references.
     // Parse and return this as an UnresolvedPatternExpr around a binding.  This
@@ -1413,12 +1419,27 @@ ParserResult<Expr> Parser::parseExprPostfix(Diag<> ID, bool isExprBasic) {
       }
 
       // 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)) {
-        Result = makeParserResult(
-          new (Context) DynamicTypeExpr(Result.get(), consumeToken(), Type()));
+        // Fix-it
+        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;
       }
 
+
       // Handle "x.self" expr.
       if (Tok.is(tok::kw_self)) {
         Result = makeParserResult(
@@ -2995,3 +3016,76 @@ Parser::parseVersionConstraintSpec() {
   return makeParserResult(new (Context) VersionConstraintAvailabilitySpec(
       Platform.getValue(), PlatformLoc, Version, VersionRange));
 }
+
+/// parseExprTypeOf
+///
+///   expr-dynamictype:
+///     'type' '(' 'of:' expr ')'
+///
+ParserResult<Expr> Parser::parseExprTypeOf() {
+  // Consume 'type'
+  SourceLoc keywordLoc = consumeToken();
+
+  // Parse the leading '('.
+  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.
+    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: ");
+  }
+
+  // Parse the subexpression.
+  ParserResult<Expr> subExpr = parseExpr(diag::expr_typeof_expected_expr);
+  if (subExpr.hasCodeCompletion())
+    return makeParserCodeCompletionResult<Expr>();
+
+  // Parse the closing ')'
+  SourceLoc rParenLoc;
+  if (subExpr.isParseError()) {
+    skipUntilDeclStmtRBrace(tok::r_paren);
+    if (Tok.is(tok::r_paren))
+      rParenLoc = consumeToken();
+    else
+      rParenLoc = Tok.getLoc();
+  } else {
+    parseMatchingToken(tok::r_paren, rParenLoc,
+                       diag::expr_typeof_expected_rparen, lParenLoc);
+  }
+
+  // If the subexpression was in error, just propagate the error.
+  if (subExpr.isParseError()) {
+    if (subExpr.hasCodeCompletion()) {
+      auto res = makeParserResult(
+                   new (Context) DynamicTypeExpr(keywordLoc, lParenLoc,
+                                                 subExpr.get(), rParenLoc,
+                                                 Type()));
+      res.setHasCodeCompletion();
+      return res;
+    } else {
+      return makeParserResult<Expr>(
+               new (Context) ErrorExpr(SourceRange(keywordLoc, rParenLoc)));
+    }
+  }
+
+  return makeParserResult(
+           new (Context) DynamicTypeExpr(keywordLoc, lParenLoc,
+                                         subExpr.get(), rParenLoc, Type()));
+}

lib/Sema/CSDiag.cpp

@@ -2267,14 +2267,14 @@ bool FailureDiagnosis::diagnoseGeneralMemberFailure(Constraint *constraint) {
           return true;
         }
 
-        // Suggest inserting '.dynamicType' to construct another object of the
-        // same dynamic type.
-        SourceLoc fixItLoc
-          = ctorRef->getNameLoc().getBaseNameLoc().getAdvancedLoc(-1);
+        // Suggest inserting a call to 'type(of:)' to construct another object
+        // of the same dynamic type.
+        SourceRange fixItRng = ctorRef->getNameLoc().getSourceRange();
 
-        // Place the '.dynamicType' right before the init.
+        // Surround the caller in `type(of:)`.
         diagnose(anchor->getLoc(), diag::init_not_instance_member)
-          .fixItInsert(fixItLoc, ".dynamicType");
+          .fixItInsert(fixItRng.Start, "type(of: ")
+          .fixItInsertAfter(fixItRng.End, ")");
         return true;
       }
     }

lib/Sema/MiscDiagnostics.cpp

@@ -486,17 +486,9 @@ static void diagSyntacticUseRestrictions(TypeChecker &TC, const Expr *E,
         return;
 
       // Allow references to types as a part of:
-      // - member references T.foo, T.Type, T.self, etc. (but *not* T.type)
+      // - member references T.foo, T.Type, T.self, etc.
       // - constructor calls T()
       if (auto *ParentExpr = Parent.getAsExpr()) {
-        // Reject use of "T.dynamicType", it should be written as "T.self".
-        if (auto metaExpr = dyn_cast<DynamicTypeExpr>(ParentExpr)) {
-          // Add a fixit to replace '.dynamicType' with '.self'.
-          TC.diagnose(E->getStartLoc(), diag::type_of_metatype)
-            .fixItReplace(metaExpr->getMetatypeLoc(), "self");
-          return;
-        }
-
         // This is the white-list of accepted syntactic forms.
         if (isa<ErrorExpr>(ParentExpr) ||
             isa<DotSelfExpr>(ParentExpr) ||               // T.self

stdlib/private/StdlibCollectionUnittest/CheckMutableCollectionType.swift.gyb

@@ -491,10 +491,10 @@ self.test("\(testNamePrefix).sorted/DispatchesThrough_withUnsafeMutableBufferPoi
   // This sort operation is not in-place.
   // The collection is copied into an array before sorting.
   expectEqual(
-    0, lc.log._withUnsafeMutableBufferPointerIfSupported[lc.dynamicType])
+    0, lc.log._withUnsafeMutableBufferPointerIfSupported[type(of: lc)])
   expectEqual(
     0,
-    lc.log._withUnsafeMutableBufferPointerIfSupportedNonNilReturns[lc.dynamicType])
+    lc.log._withUnsafeMutableBufferPointerIfSupportedNonNilReturns[type(of: lc)])
 
   expectEqualSequence([ 1, 2, 3, 4, 5 ], extractedResult.map { $0.value })
 }
@@ -808,10 +808,10 @@ self.test("\(testNamePrefix).partition/DispatchesThrough_withUnsafeMutableBuffer
   })
 
   expectEqual(
-    1, lc.log._withUnsafeMutableBufferPointerIfSupported[lc.dynamicType])
+    1, lc.log._withUnsafeMutableBufferPointerIfSupported[type(of: lc)])
   expectEqual(
     withUnsafeMutableBufferPointerIsSupported ? 1 : 0,
-    lc.log._withUnsafeMutableBufferPointerIfSupportedNonNilReturns[lc.dynamicType])
+    lc.log._withUnsafeMutableBufferPointerIfSupportedNonNilReturns[type(of: lc)])
 
   expectEqual(4, lc.distance(from: lc.startIndex, to: pivot))
   expectEqualsUnordered([1, 2, 3, 4], lc.prefix(upTo: pivot).map { extractValue($0).value })

stdlib/private/StdlibCollectionUnittest/LoggingWrappers.swift.gyb

@@ -32,7 +32,7 @@ extension LoggingType {
   }
 
   public var selfType: Any.Type {
-    return self.dynamicType
+    return type(of: self)
   }
 }
 

stdlib/private/StdlibCollectionUnittest/MinimalCollections.swift.gyb

@@ -555,7 +555,7 @@ public struct ${Self}<T> : ${SelfProtocols} {
     self.underestimatedCount = 0
     self._elements = []
     self._collectionState =
-      _CollectionState(name: "\(self.dynamicType)", elementCount: 0)
+      _CollectionState(name: "\(type(of: self))", elementCount: 0)
   }
 
   public init<S : Sequence>(_ elements: S) where S.Iterator.Element == T {