Merge pull request #4799 from rudkx/type-checker-perf-swift-3.0-branch

Pull in some type checker performance improvements

Author: tkremenek

include/swift/AST/Expr.h

@@ -1421,7 +1421,11 @@ class OverloadSetRefExpr : public Expr {
 
 public:
   ArrayRef<ValueDecl*> getDecls() const { return Decls; }
-  
+
+  void setDecls(ArrayRef<ValueDecl *> domain) {
+    Decls = domain;
+  }
+
   /// getBaseType - Determine the type of the base object provided for the
   /// given overload set, which is only non-null when dealing with an overloaded
   /// member reference.
@@ -4295,29 +4299,6 @@ class AssignExpr : public Expr {
   }
 };
 
-/// \brief An expression that describes the use of a default value, which may
-/// come from the default argument of a function type or member initializer.
-///
-/// This expression is synthesized by type checking and cannot be written
-/// directly by the user.
-class DefaultValueExpr : public Expr {
-  Expr *subExpr;
-
-public:
-  explicit DefaultValueExpr(Expr *subExpr)
-    : Expr(ExprKind::DefaultValue, /*Implicit=*/true, subExpr->getType()),
-      subExpr(subExpr) { }
-
-  Expr *getSubExpr() const { return subExpr; }
-  void setSubExpr(Expr *sub) { subExpr = sub; }
-  
-  SourceRange getSourceRange() const { return SourceRange(); }
-
-  static bool classof(const Expr *E) {
-    return E->getKind() == ExprKind::DefaultValue;
-  }
-};
-  
 /// \brief A pattern production that has been parsed but hasn't been resolved
 /// into a complete pattern. Name binding converts these into standalone pattern
 /// nodes or raises an error if a pattern production appears in an invalid

include/swift/AST/ExprNodes.def

@@ -154,7 +154,6 @@ UNCHECKED_EXPR(Arrow, Expr)
 EXPR(If, Expr)
 EXPR(EnumIsCase, Expr)
 EXPR(Assign, Expr)
-EXPR(DefaultValue, Expr)
 EXPR(CodeCompletion, Expr)
 UNCHECKED_EXPR(UnresolvedPattern, Expr)
 EXPR(EditorPlaceholder, Expr)

lib/AST/ASTDumper.cpp

@@ -2212,11 +2212,6 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     printRec(E->getElseExpr());
     OS << ')';
   }
-  void visitDefaultValueExpr(DefaultValueExpr *E) {
-    printCommon(E, "default_value_expr") << ' ';
-    printRec(E->getSubExpr());
-    OS << ')';
-  }
   void visitAssignExpr(AssignExpr *E) {
     OS.indent(Indent) << "(assign_expr\n";
     printRec(E->getDest());

lib/AST/ASTWalker.cpp

@@ -800,14 +800,6 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
     return E;
   }
 
-  Expr *visitDefaultValueExpr(DefaultValueExpr *E) {
-    Expr *sub = doIt(E->getSubExpr());
-    if (!sub) return nullptr;
-
-    E->setSubExpr(sub);
-    return E;
-  }
-  
   Expr *visitUnresolvedPatternExpr(UnresolvedPatternExpr *E) {
     Pattern *sub = doIt(E->getSubPattern());
     if (!sub) return nullptr;

lib/AST/Expr.cpp

@@ -178,9 +178,6 @@ Expr *Expr::getSemanticsProvidingExpr() {
   if (TryExpr *TE = dyn_cast<TryExpr>(this))
     return TE->getSubExpr()->getSemanticsProvidingExpr();
 
-  if (DefaultValueExpr *DE = dyn_cast<DefaultValueExpr>(this))
-    return DE->getSubExpr()->getSemanticsProvidingExpr();
-  
   return this;
 }
 
@@ -343,7 +340,6 @@ void Expr::propagateLValueAccessKind(AccessKind accessKind,
     NON_LVALUE_EXPR(OptionalEvaluation)
     NON_LVALUE_EXPR(If)
     NON_LVALUE_EXPR(Assign)
-    NON_LVALUE_EXPR(DefaultValue)
     NON_LVALUE_EXPR(CodeCompletion)
     NON_LVALUE_EXPR(ObjCSelector)
     NON_LVALUE_EXPR(ObjCKeyPath)
@@ -485,7 +481,6 @@ ConcreteDeclRef Expr::getReferencedDecl() const {
   NO_REFERENCE(If);
   NO_REFERENCE(EnumIsCase);
   NO_REFERENCE(Assign);
-  NO_REFERENCE(DefaultValue);
   NO_REFERENCE(CodeCompletion);
   NO_REFERENCE(UnresolvedPattern);
   NO_REFERENCE(EditorPlaceholder);
@@ -784,7 +779,6 @@ bool Expr::canAppendCallParentheses() const {
   case ExprKind::Arrow:
   case ExprKind::If:
   case ExprKind::Assign:
-  case ExprKind::DefaultValue:
   case ExprKind::UnresolvedPattern:
   case ExprKind::EditorPlaceholder:
     return false;

lib/SILGen/SILGenExpr.cpp

@@ -214,7 +214,6 @@ namespace {
                                              SGFContext C);
     RValue visitIfExpr(IfExpr *E, SGFContext C);
 
-    RValue visitDefaultValueExpr(DefaultValueExpr *E, SGFContext C);
     RValue visitAssignExpr(AssignExpr *E, SGFContext C);
     RValue visitEnumIsCaseExpr(EnumIsCaseExpr *E, SGFContext C);
 
@@ -2581,10 +2580,6 @@ RValue RValueEmitter::visitIfExpr(IfExpr *E, SGFContext C) {
   }
 }
 
-RValue RValueEmitter::visitDefaultValueExpr(DefaultValueExpr *E, SGFContext C) {
-  return visit(E->getSubExpr(), C);
-}
-
 RValue SILGenFunction::emitEmptyTupleRValue(SILLocation loc,
                                             SGFContext C) {
   return RValue(CanType(TupleType::getEmpty(F.getASTContext())));

lib/Sema/CSApply.cpp

@@ -2869,10 +2869,6 @@ namespace {
       llvm_unreachable("Already type-checked");
     }
 
-    Expr *visitDefaultValueExpr(DefaultValueExpr *expr) {
-      llvm_unreachable("Already type-checked");
-    }
-
     Expr *visitApplyExpr(ApplyExpr *expr) {
       return finishApply(expr, expr->getType(),
                          ConstraintLocatorBuilder(
@@ -6456,10 +6452,6 @@ namespace {
     }
 
     std::pair<bool, Expr *> walkToExprPre(Expr *expr) override {
-      // For a default-value expression, do nothing.
-      if (isa<DefaultValueExpr>(expr))
-        return { false, expr };
-
       // For closures, update the parameter types and check the body.
       if (auto closure = dyn_cast<ClosureExpr>(expr)) {
         Rewriter.simplifyExprType(expr);

lib/Sema/CSGen.cpp

@@ -2310,11 +2310,6 @@ namespace {
       return expr->getType();
     }
 
-    Type visitDefaultValueExpr(DefaultValueExpr *expr) {
-      expr->setType(expr->getSubExpr()->getType());
-      return expr->getType();
-    }
-
     Type visitApplyExpr(ApplyExpr *expr) {
       Type outputTy;
 
@@ -2757,11 +2752,6 @@ namespace {
   public:
     SanitizeExpr(TypeChecker &tc) : TC(tc) { }
 
-    std::pair<bool, Expr *> walkToExprPre(Expr *expr) override {
-      // Don't recurse into default-value expressions.
-      return { !isa<DefaultValueExpr>(expr), expr };
-    }
-
     Expr *walkToExprPost(Expr *expr) override {
       if (auto implicit = dyn_cast<ImplicitConversionExpr>(expr)) {
         // Skip implicit conversions completely.
@@ -2841,12 +2831,6 @@ namespace {
         return { true, expr };
       }
 
-      // We don't visit default value expressions; they've already been
-      // type-checked.
-      if (isa<DefaultValueExpr>(expr)) {
-        return { false, expr };
-      }
-
       // Don't visit CoerceExpr with an empty sub expression. They may occur
       // if the body of a closure was not visited while pre-checking because
       // of an error in the closure's signature