Normalize the way paren types are stripped in Sema.

lib/AST/ASTVerifier.cpp

@@ -1487,9 +1487,7 @@ struct ASTNodeBase {};
       /// Retrieve the ith element type from the resulting tuple type.
       auto getOuterElementType = [&](unsigned i) -> Type {
         if (!TT) {
-          if (auto parenTy = dyn_cast<ParenType>(E->getType().getPointer()))
+          return E->getType()->getWithoutParens();
-            return parenTy->getUnderlyingType();
-          return E->getType();
         }
 
         return TT->getElementType(i);

lib/Sema/CSDiag.cpp

@@ -6388,10 +6388,8 @@ bool FailureDiagnosis::visitIdentityExpr(IdentityExpr *E) {
   
   // If we have a paren expr and our contextual type is a ParenType, remove the
   // paren expr sugar.
-  if (isa<ParenExpr>(E) && contextualType)
+  if (contextualType)
-    if (auto *PT = dyn_cast<ParenType>(contextualType.getPointer()))
+    contextualType = contextualType->getWithoutParens();
-      contextualType = PT->getUnderlyingType();
-  
   if (!typeCheckChildIndependently(E->getSubExpr(), contextualType,
                                    CS->getContextualTypePurpose()))
     return true;

lib/Sema/CSGen.cpp

@@ -699,14 +699,6 @@ namespace {
     return NTD->getHasFailableInits();
   }
   
-  Type getInnerParenType(const Type &t) {
-    if (auto parenType = dyn_cast<ParenType>(t.getPointer())) {
-      return getInnerParenType(parenType->getUnderlyingType());
-    }
-    
-    return t;
-  }
-  
   size_t getOperandCount(Type t) {
     size_t nOperands = 0;
     
@@ -874,8 +866,8 @@ namespace {
     auto argTy = expr->getArg()->getType();
     auto argTupleTy = argTy->castTo<TupleType>();
     auto argTupleExpr = dyn_cast<TupleExpr>(expr->getArg());
-    Type firstArgTy = getInnerParenType(argTupleTy->getElement(0).getType());
+    Type firstArgTy = argTupleTy->getElement(0).getType()->getWithoutParens();
-    Type secondArgTy = getInnerParenType(argTupleTy->getElement(1).getType());
+    Type secondArgTy = argTupleTy->getElement(1).getType()->getWithoutParens();
     
     // Determine whether the given declaration is favored.
     auto isFavoredDecl = [&](ValueDecl *value) -> bool {

lib/Sema/CSSimplify.cpp

@@ -2839,13 +2839,7 @@ performMemberLookup(ConstraintKind constraintKind, DeclName memberName,
           if (auto fnType =
                   fnTypeWithSelf->getResult()->getAs<FunctionType>()) {
           
-            auto argType = fnType->getInput();
+            auto argType = fnType->getInput()->getWithoutParens();
-            
-            if (auto parenType =
-                dyn_cast<ParenType>(argType.getPointer())) {
-              argType = parenType->getUnderlyingType();
-            }
-            
             if (argType->isEqual(favoredType))
               result.FavoredChoice = result.ViableCandidates.size();
           }

lib/Sema/MiscDiagnostics.cpp

@@ -3924,10 +3924,7 @@ static OmissionTypeName getTypeNameForOmission(Type type) {
     }
 
     // Look through parentheses.
-    if (auto parenTy = dyn_cast<ParenType>(type.getPointer())) {
+    type = type->getWithoutParens();
-      type = parenTy->getUnderlyingType();
-      continue;
-    }
 
     // Look through optionals.
     if (auto optObjectTy = type->getAnyOptionalObjectType()) {

lib/Sema/TypeCheckExpr.cpp

@@ -54,8 +54,7 @@ static void substituteInputSugarArgumentType(Type argTy, CanType resultTy,
 
   // If this type is parenthesized, remove the parens.  We don't want to
   // propagate parens from arguments to the result type.
-  if (auto *PT = dyn_cast<ParenType>(argTy.getPointer()))
+  argTy = argTy->getWithoutParens();
-    argTy = PT->getUnderlyingType();
   
   // If this is the first match against the sugar type we found, use it.
   if (!resultSugarTy) {