Remove usage of getMetatypeLoc()

Author: CodaFi

include/swift/AST/DiagnosticsSema.def

@@ -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

@@ -3519,28 +3519,34 @@ class AutoClosureExpr : public AbstractClosureExpr {
 
 /// 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/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

@@ -1420,6 +1420,8 @@ 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)) {
         // Fix-it
         auto range = Result.get()->getSourceRange();
@@ -1429,8 +1431,11 @@ ParserResult<Expr> Parser::parseExprPostfix(Diag<> ID, bool isExprBasic) {
           .fixItReplace(dynamicTypeExprRange, ")")
           .fixItInsert(range.Start, "type(of: ");
 
-        Result = makeParserResult(
-          new (Context) DynamicTypeExpr(Result.get(), dynamicTypeExprRange.End, Type()));
+        // HACK: Arbitrary.
+        auto loc = range.Start;
+        auto dt = new (Context) DynamicTypeExpr(loc, loc, Result.get(), loc, Type());
+        dt->setImplicit();
+        Result = makeParserResult(dt);
         continue;
       }
 
@@ -3018,23 +3023,33 @@ Parser::parseVersionConstraintSpec() {
 ///     'type' '(' 'of:' expr ')'
 ///
 ParserResult<Expr> Parser::parseExprTypeOf() {
-
-  assert(Tok.getText() == "type" && "only 'type' should be handled here");
-
   // Consume 'type'
   SourceLoc keywordLoc = consumeToken();
-  // Consume '('
+
+  // Parse the leading '('.
   SourceLoc lParenLoc = consumeToken(tok::l_paren);
 
-  // Parse `of` label
-  // If we see a potential argument label followed by a ':', consume
-  // it.
-  if (Tok.canBeArgumentLabel() && Tok.getText() == "of" && peekToken().is(tok::colon)) {
+  // 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 {
-    diagnose(Tok, diag::expr_typeof_expected_label_of);
-    return makeParserError();
+    // No label at all; insert it.
+    diagnose(Tok, diag::expr_typeof_expected_label_of)
+      .fixItInsert(ofRange.getStart(), "of: ");
   }
 
   // Parse the subexpression.
@@ -3059,15 +3074,18 @@ ParserResult<Expr> Parser::parseExprTypeOf() {
   if (subExpr.isParseError()) {
     if (subExpr.hasCodeCompletion()) {
       auto res = makeParserResult(
-                                  new (Context) DynamicTypeExpr(subExpr.get(), consumeToken(), Type()));
+                   new (Context) DynamicTypeExpr(keywordLoc, lParenLoc,
+                                                 subExpr.get(), rParenLoc,
+                                                 Type()));
       res.setHasCodeCompletion();
       return res;
     } else {
       return makeParserResult<Expr>(
-                                    new (Context) ErrorExpr(SourceRange(keywordLoc, rParenLoc)));
+               new (Context) ErrorExpr(SourceRange(keywordLoc, rParenLoc)));
     }
   }
 
   return makeParserResult(
-                          new (Context) DynamicTypeExpr(subExpr.get(), rParenLoc, Type()));
+           new (Context) DynamicTypeExpr(keywordLoc, lParenLoc,
+                                         subExpr.get(), rParenLoc, Type()));
 }

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

test/Parse/type_expr.swift

@@ -53,7 +53,6 @@ func unqualifiedType() {
   _ = Foo.instMeth
 
   _ = Foo // expected-error{{expected member name or constructor call after type name}} expected-note{{add arguments}} {{10-10=()}} expected-note{{use '.self'}} {{10-10=.self}}
-  _ = type(of: Foo) // expected-error{{'.dynamicType' is not allowed after a type name}} {{11-22=self}}
 
   _ = Bad // expected-error{{expected member name or constructor call after type name}}
   // expected-note@-1{{use '.self' to reference the type object}}{{10-10=.self}}
@@ -70,7 +69,6 @@ func qualifiedType() {
   _ = Foo.Bar.instMeth
 
   _ = Foo.Bar // expected-error{{expected member name or constructor call after type name}} expected-note{{add arguments}} {{14-14=()}} expected-note{{use '.self'}} {{14-14=.self}}
-  _ = type(of: Foo.Bar) // expected-error{{'.dynamicType' is not allowed after a type name}} {{15-26=self}}
 }
 
 /* TODO allow '.Type' in expr context
@@ -90,11 +88,9 @@ func genType() {
   _ = Gen<Foo>.meth
   let _ : () = Gen<Foo>.meth()
   _ = Gen<Foo>.instMeth
-
-  // Misparses because generic parameter disambiguation rejects '>' not
-  // followed by '.' or '('
-  _ = Gen<Foo> // expected-error{{not a postfix unary operator}}
-  _ = Gen<Foo>.dynamicType // expected-error{{'.dynamicType' is not allowed after a type name}} {{16-27=self}}
+  _ = Gen<Foo> // expected-error{{expected member name or constructor call after type name}}
+               // expected-note@-1{{use '.self' to reference the type object}}
+               // expected-note@-2{{add arguments after the type to construct a value of the type}}
 }
 
 func genQualifiedType() {
@@ -106,7 +102,9 @@ func genQualifiedType() {
   _ = Gen<Foo>.Bar.instMeth
 
   _ = Gen<Foo>.Bar
-  _ = type(of: Gen<Foo>.Bar)
+  _ = type(of: Gen<Foo>.Bar) // No error here.
+  _ = type(Gen<Foo>.Bar) // expected-error {{expected argument label 'of:' within 'type(...)'}} {{12-12=of: }}
+  _ = type(fo: Gen<Foo>.Bar) // expected-error {{expected argument label 'of:' within 'type(...)'}} 
 }
 
 func archetype<T: Zim>(_: T) {
@@ -117,7 +115,6 @@ func archetype<T: Zim>(_: T) {
   let _ : () = T.meth()
 
   _ = T // expected-error{{expected member name or constructor call after type name}} expected-note{{add arguments}} {{8-8=()}} expected-note{{use '.self'}} {{8-8=.self}}
-  _ = type(of: T) // expected-error{{'.dynamicType' is not allowed after a type name}} {{9-20=self}}
 }
 
 func assocType<T: Zim>(_: T) where T.Zang: Zim {
@@ -128,7 +125,6 @@ func assocType<T: Zim>(_: T) where T.Zang: Zim {
   let _ : () = T.Zang.meth()
 
   _ = T.Zang // expected-error{{expected member name or constructor call after type name}} expected-note{{add arguments}} {{13-13=()}} expected-note{{use '.self'}} {{13-13=.self}}
-  _ = type(of: T.Zang) // expected-error{{'.dynamicType' is not allowed after a type name}} {{14-25=self}}
 }
 
 class B {
@@ -149,7 +145,6 @@ func derivedType() {
 
   let _: B.Type = D // expected-error{{expected member name or constructor call after type name}} expected-note{{add arguments}} {{20-20=()}} expected-note{{use '.self'}} {{20-20=.self}}
   let _: D.Type = D // expected-error{{expected member name or constructor call after type name}} expected-note{{add arguments}} {{20-20=()}} expected-note{{use '.self'}} {{20-20=.self}}
-  let _: D.Type.Type = type(of: D) // expected-error{{'.dynamicType' is not allowed after a type name}} {{26-37=self}}
 }
 
 // Referencing a nonexistent member or constructor should not trigger errors

test/SILGen/optional_chain_addressor.swift

@@ -2,5 +2,5 @@
 
 func foo(x: UnsafeMutablePointer<UnsafeMutablePointer<()>?>) {
   _ = x.pointee?.pointee
-  _ = type(of: x.pointee?)
+  _ = type(of: x.pointee)
 }

test/SILOptimizer/cast_folding.swift

@@ -509,7 +509,7 @@ func test18_2() -> Bool {
 // CHECK-NEXT: return %1
 @inline(never)
 func test19() -> Bool {
-    let t: Any.Type = (1 as Any).dynamicType
+    let t: Any.Type = type(of: 1 as Any)
     return t is Int.Type
 }
 

test/expr/postfix/dot/init_ref_delegation.swift

@@ -101,7 +101,7 @@ enum Z2 {
 // Ill-formed initialization: wrong context.
 class Z3 {
   func f() {
-    self.init() // expected-error{{'init' is a member of the type; insert '.dynamicType' to initialize a new object of the same dynamic type}} {{9-9=.dynamicType}}
+    self.init() // expected-error{{'init' is a member of the type; use 'type(of: ...)' to initialize a new object of the same dynamic type}} {{10-10=type(of: }} {{14-14=)}} 
   }
 
   init() { }
@@ -112,7 +112,7 @@ class Z4 {
   init() {} // expected-note{{selected non-required initializer}}
 
   convenience init(other: Z4) {
-    other.init() // expected-error{{'init' is a member of the type; insert '.dynamicType' to initialize a new object of the same dynamic type}} {{10-10=.dynamicType}}
+    other.init() // expected-error{{'init' is a member of the type; use 'type(of: ...)' to initialize a new object of the same dynamic type}} {{11-11=type(of: }} {{15-15=)}} 
     type(of: other).init() // expected-error{{must use a 'required' initializer}} expected-warning{{unused}}
   }
 }
@@ -121,7 +121,7 @@ class Z5 : Z4 {
   override init() { }
 
   convenience init(other: Z5) {
-    other.init() // expected-error{{'init' is a member of the type; insert '.dynamicType' to initialize a new object of the same dynamic type}} {{10-10=.dynamicType}}
+    other.init() // expected-error{{'init' is a member of the type; use 'type(of: ...)' to initialize a new object of the same dynamic type}} {{11-11=type(of: }} {{15-15=)}} 
   }
 }
 
@@ -150,7 +150,7 @@ struct RDar16603812 {
    var i = 42
    init() {}
    func foo() {
-      self.init() // expected-error {{'init' is a member of the type; insert '.dynamicType' to initialize a new object of the same dynamic type}} {{11-11=.dynamicType}}
+      self.init() // expected-error {{'init' is a member of the type; use 'type(of: ...)' to initialize a new object of the same dynamic type}} {{12-12=type(of: }} {{16-16=)}} 
       type(of: self).init() // expected-warning{{result of 'RDar16603812' initializer is unused}}
    }
 }
@@ -199,7 +199,7 @@ class D: C {
   }
 
   func foo() {
-    self.init(x: 0) // expected-error{{'init' is a member of the type; insert '.dynamicType' to initialize a new object of the same dynamic type}} {{9-9=.dynamicType}}
+    self.init(x: 0) // expected-error{{'init' is a member of the type; use 'type(of: ...)' to initialize a new object of the same dynamic type}} {{10-10=type(of: }} {{14-14=)}} 
   }
   func bar() {
     super.init(x: 0) // expected-error{{'super.init' cannot be called outside of an initializer}}
@@ -270,10 +270,10 @@ func foo<T: C>(_ x: T, y: T.Type) where T: P {
   var c3a = type(of: x).init() // expected-error{{'required' initializer}}
   var c4a = type(of: x).init(proto: "")
 
-  var ci1 = x.init(required: 0) // expected-error{{'init' is a member of the type; insert '.dynamicType' to initialize a new object of the same dynamic type}} {{14-14=.dynamicType}}
-  var ci2 = x.init(x: 0) // expected-error{{'init' is a member of the type; insert '.dynamicType' to initialize a new object of the same dynamic type}} {{14-14=.dynamicType}}
-  var ci3 = x.init() // expected-error{{'init' is a member of the type; insert '.dynamicType' to initialize a new object of the same dynamic type}} {{14-14=.dynamicType}}
-  var ci4 = x.init(proto: "") // expected-error{{'init' is a member of the type; insert '.dynamicType' to initialize a new object of the same dynamic type}} {{14-14=.dynamicType}}
+  var ci1 = x.init(required: 0) // expected-error{{'init' is a member of the type; use 'type(of: ...)' to initialize a new object of the same dynamic type}} {{15-15=type(of: }} {{19-19=)}} 
+  var ci2 = x.init(x: 0) // expected-error{{'init' is a member of the type; use 'type(of: ...)' to initialize a new object of the same dynamic type}} {{15-15=type(of: }} {{19-19=)}} 
+  var ci3 = x.init() // expected-error{{'init' is a member of the type; use 'type(of: ...)' to initialize a new object of the same dynamic type}} {{15-15=type(of: }} {{19-19=)}} 
+  var ci4 = x.init(proto: "") // expected-error{{'init' is a member of the type; use 'type(of: ...)' to initialize a new object of the same dynamic type}} {{15-15=type(of: }} {{19-19=)}} 
 
   var ci1a = x(required: 0) // expected-error{{cannot call value of non-function type 'T'}}
   var ci2a = x(x: 0) // expected-error{{cannot call value of non-function type 'T'}}