[CodeComplete] Propagate preferred types through parser in more cases

[ilya-biryukov]

Summary

Preferred types are used by code completion for ranking. This commit
considerably increases the number of points in code where those types
are propagated.

In order to avoid complicating signatures of Parser's methods, a
preferred type is kept as a member variable in the parser and updated
during parsing.

[ilya-biryukov]

@kadircet for preferred-type related bits.
@rsmith for parser-related bits. More specifically, (1) should we be worried that this might affect parser performance on the hot path and (2) whether there are better alternatives to do something like this.

[kadircet]

That really looks awesome, thanks!

One general comment: I am not really sure if the handling done in ParseCastExpression is extensive enough. But IIUC, this should not cause any regressions, rather should result in missing preferred types just as before this patch ?

lib/Parse/ParseExpr.cpp

1157

shouldn't we have an enterunknown here as well?

lib/Sema/SemaCodeComplete.cpp

352

I am not sure it carries the weight, why not just inline it?

360

Is this check necessary? According to comments getCurBlock returns null if there is no block.

373

nit: maybe move this into top and get rid of the return statements inside ifs(also by changing them to else ifs)

380

Is it really possible for D to be null ?

[ilya-biryukov]

Thanks for a quick response, @kadircet!
Leaving some first comments, will address the rest later.

In D56723#1361366, @kadircet wrote:

One general comment: I am not really sure if the handling done in ParseCastExpression is extensive enough. But IIUC, this should not cause any regressions, rather should result in missing preferred types just as before this patch ?

Exactly, no regressions are expected, we should start providing a preferred type in more places after this change.
This change is aiming to establish a well-defined pattern on how to add these types, more changes will follow to actually propagate the types in more cases.

lib/Sema/SemaCodeComplete.cpp

360

This was copy-pasted from the removed codeCompleteReturn. I'd keep it this way in the initial patch to make sure we don't change semantics in existing cases.

[rsmith]

This seems to be introducing a requirement that enterUnknown is called on all paths through the parser where we recurse to parse a subexpression and don't have specific type information. That seems like an unfortunate requirement to me from a maintenance perspective; have you considered alternative approaches? For example, we could store the preferred type alongside the SourceLocation of the corresponding token (and propagate the information when we parse parentheses and any other completion-type-preserving construct), and only apply the information when the code completion token is at that location. That way, we only need to annotate cases where we know the preferred type, not when we don't.

[ilya-biryukov]

Thanks for the suggestion, this should definitely work! I did struggle to figure out a way to do this without annotating every path with enterUnknown and failed.
I'll try playing around with your idea, my initial plan is to store preferred type alongside the current token as a member of the Parser class and update it when advancing to next token, when the parser backtracks and in the places where we care about propagating the types.

[rsmith]

In D56723#1366529, @ilya-biryukov wrote:

I'll try playing around with your idea, my initial plan is to store preferred type alongside the current token as a member of the Parser class and update it when advancing to next token, when the parser backtracks and in the places where we care about propagating the types.

ConsumeToken is a fairly hot function; if you can avoid changes there that'd be preferable. Tracking this automatically across tentative parse / rollback seems like a very nice idea.

[ilya-biryukov]

• Remove enterUnknown(), keep token location instead.
• Inline update() and remove it

[ilya-biryukov]

lib/Sema/SemaCodeComplete.cpp

373

FWIW I find ifs with return to be more readable than a bunch of if+else statements. The reason is that return clearly states function is done, while trailing else suggests it will go further.

But this particular function is short, so it's not a strong argument, can change it if you insist.

380

Probably shouldn't, but I can't be certain, I'm too lazy to inspect all code paths in the parser, so I'd simply rely on the types used there and assume this could happen.

I'll try adding an assertion and finding the example when it happens, though.

[ilya-biryukov]

In D56723#1366885, @rsmith wrote:

ConsumeToken is a fairly hot function; if you can avoid changes there that'd be preferable.

Done, there are no enterUnknown calls anymore and to avoid updating on each call to ConsumeToken we now store a location of the token we computed the expected type for.
The resulting code looks ok to my taste, let me know what you think.

Initially I thought this approach would allow to get rid of the RAII object to restore the type, but I don't see a good alternative to it even with the new approach.

[ilya-biryukov]

• Improve a comment

[ilya-biryukov]

• Use 'else if' to simplify the code

[ilya-biryukov]

lib/Sema/SemaCodeComplete.cpp

373

On a second thought, I think my approach makes it uglier. The function is small, so the added "return R" everywhere only make it uglier.

Changed the code per your suggestions, thanks!

[rsmith]

clang/include/clang/Sema/Sema.h

319–346 ↗

(On Diff #183937)

Now we store a location along with the expected type, I don't think we need an RAII object any more. (We would need to save/restore in tentative parsing, if we ever called any of the parsing functions that set a preferred type, but tentative parsing shouldn't be doing that.)

[ilya-biryukov]

clang/include/clang/Sema/Sema.h

319–346 ↗

(On Diff #183937)

No RAII objects anymore. By keeping them I intended to simplify the requirements on the callers that wouldn't need to worry about restoring the expected type after parsing parts of an expression.
In practice, it's not a big burden and the resulting code looks even more concise. There are surely some cases we're missing, but it's fine, we'll track them down later and missing expected type in some cases is totally ok.

[ilya-biryukov]

• Get rid of the RAII object

[kadircet]

LGTM from my side

include/clang/Parse/Parser.h

class Parser : public CodeCompletionHandler {
   /// should not be set directly.
   bool InMessageExpression;
 
   /// Gets set to true after calling ProduceSignatureHelp, it is for a
   /// workaround to make sure ProduceSignatureHelp is only called at the deepest
   /// function call.
   bool CalledSignatureHelp = false;
 
+  /// Tracks expected type of the expression currently being parsed.
+  /// Used by code completion for ranking.
+  PreferredTypeBuilder PreferredType;
+
   /// The "depth" of the template parameters currently being parsed.
   unsigned TemplateParameterDepth;
 
   /// RAII class that manages the template parameter depth.
   class TemplateParameterDepthRAII {
     unsigned &Depth;
     unsigned AddedLevels;
   public:

include/clang/Sema/CodeCompleteConsumer.h

public:
 
   /// Retrieve the kind of code-completion context.
   Kind getKind() const { return CCKind; }
 
   /// Retrieve the type that this expression would prefer to have, e.g.,
   /// if the expression is a variable initializer or a function argument, the
   /// type of the corresponding variable or function parameter.
   QualType getPreferredType() const { return PreferredType; }
+  void setPreferredType(QualType T) { PreferredType = T; }
 
   /// Retrieve the type of the base object in a member-access
   /// expression.
   QualType getBaseType() const { return BaseType; }
 
   /// Retrieve the Objective-C selector identifiers.
   ArrayRef<IdentifierInfo *> getSelIdents() const { return SelIdents; }
 

include/clang/Sema/Sema.h

FileNullability &operator[](FileID file) {
 
     // Pull this entry into the cache.
     Cache.File = file;
     Cache.Nullability = Map[file];
     return Cache.Nullability;
   }
 };
 
+/// Keeps track of expected type during expression parsing.
+class PreferredTypeBuilder {
+public:
+  class RestoreRAII;
+
+  PreferredTypeBuilder() = default;
+  explicit PreferredTypeBuilder(QualType Type) : Type(Type) {}
+
+  LLVM_NODISCARD RestoreRAII enterUnknown();
+  LLVM_NODISCARD RestoreRAII enterCondition(Sema &S);
+  LLVM_NODISCARD RestoreRAII enterReturn(Sema &S);
+  LLVM_NODISCARD RestoreRAII enterVariableInit(Decl *D);
+
+  LLVM_NODISCARD RestoreRAII enterUnary(Sema &S, tok::TokenKind Op);
+  LLVM_NODISCARD RestoreRAII enterBinary(Sema &S, Expr *LHS, tok::TokenKind Op);
+  LLVM_NODISCARD RestoreRAII enterSubscript(Sema &S, Expr *LHS);
+  /// Handles all type casts, including C-style cast, C++ casts, etc.
+  LLVM_NODISCARD RestoreRAII enterTypeCast(QualType CastType);
+
+  QualType get() const { return Type; }
+
+private:
+  LLVM_NODISCARD RestoreRAII update(llvm::function_ref<void()> Updater);
+
+  QualType Type;
+};
+
+class PreferredTypeBuilder::RestoreRAII {
+public:
+  RestoreRAII(RestoreRAII const &) = delete;
+  RestoreRAII &operator=(RestoreRAII const &) = delete;
+
+  explicit RestoreRAII(PreferredTypeBuilder &Builder)
+      : Old(Builder.Type), Builder(&Builder) {}
+
+  RestoreRAII(RestoreRAII &&Other) {
+    Old = Other.Old;
+    Builder = Other.Builder;
+
+    Other.Builder = nullptr;
+  }
+
+  ~RestoreRAII() {
+    if (!Builder)
+      return;
+    Builder->Type = Old;
+  }
+
+private:
+  QualType Old;
+  PreferredTypeBuilder *Builder;
+};
+
 /// Sema - This implements semantic analysis and AST building for C.
 class Sema {
   Sema(const Sema &) = delete;
   void operator=(const Sema &) = delete;
 
   ///Source of additional semantic information.
   ExternalSemaSource *ExternalSource;
 
void CodeCompleteOrdinaryName(Scope *S,
                                 ParserCompletionContext CompletionContext);
   void CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
                             bool AllowNonIdentifiers,
                             bool AllowNestedNameSpecifiers);
 
   struct CodeCompleteExpressionData;
   void CodeCompleteExpression(Scope *S,
                               const CodeCompleteExpressionData &Data);
-  void CodeCompleteExpression(Scope *S, QualType PreferredType);
+  void CodeCompleteExpression(Scope *S, QualType PreferredType,
+                              bool IsParenthesized = false);
   void CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base, Expr *OtherOpBase,
                                        SourceLocation OpLoc, bool IsArrow,
-                                       bool IsBaseExprStatement);
-  void CodeCompletePostfixExpression(Scope *S, ExprResult LHS);
+                                       bool IsBaseExprStatement,
+                                       QualType PreferredType);
+  void CodeCompletePostfixExpression(Scope *S, ExprResult LHS,
+                                     QualType PreferredType);
   void CodeCompleteTag(Scope *S, unsigned TagSpec);
   void CodeCompleteTypeQualifiers(DeclSpec &DS);
   void CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D,
                                       const VirtSpecifiers *VS = nullptr);
   void CodeCompleteBracketDeclarator(Scope *S);
   void CodeCompleteCase(Scope *S);
   /// Reports signatures for a call to CodeCompleteConsumer and returns the
   /// preferred type for the current argument. Returned type can be null.
   QualType ProduceCallSignatureHelp(Scope *S, Expr *Fn, ArrayRef<Expr *> Args,
                                     SourceLocation OpenParLoc);
   QualType ProduceConstructorSignatureHelp(Scope *S, QualType Type,
                                            SourceLocation Loc,
                                            ArrayRef<Expr *> Args,
                                            SourceLocation OpenParLoc);
   QualType ProduceCtorInitMemberSignatureHelp(Scope *S, Decl *ConstructorDecl,
                                               CXXScopeSpec SS,
                                               ParsedType TemplateTypeTy,
                                               ArrayRef<Expr *> ArgExprs,
                                               IdentifierInfo *II,
                                               SourceLocation OpenParLoc);
   void CodeCompleteInitializer(Scope *S, Decl *D);
-  void CodeCompleteReturn(Scope *S);
   void CodeCompleteAfterIf(Scope *S);
-  void CodeCompleteBinaryRHS(Scope *S, Expr *LHS, tok::TokenKind Op);
 
   void CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
                                bool EnteringContext, QualType BaseType);
   void CodeCompleteUsing(Scope *S);
   void CodeCompleteUsingDirective(Scope *S);
   void CodeCompleteNamespaceDecl(Scope *S);
   void CodeCompleteNamespaceAliasDecl(Scope *S);
   void CodeCompleteOperatorName(Scope *S);

lib/Parse/ParseDecl.cpp

 ///         specifier-qualifier-list abstract-declarator[opt]
 ///
 /// Called type-id in C++.
 TypeResult Parser::ParseTypeName(SourceRange *Range,
                                  DeclaratorContext Context,
                                  AccessSpecifier AS,
                                  Decl **OwnedType,
                                  ParsedAttributes *Attrs) {
+  auto TypeRAII = PreferredType.enterUnknown();
+
   DeclSpecContext DSC = getDeclSpecContextFromDeclaratorContext(Context);
   if (DSC == DeclSpecContext::DSC_normal)
     DSC = DeclSpecContext::DSC_type_specifier;
 
   // Parse the common declaration-specifiers piece.
   DeclSpec DS(AttrFactory);
   if (Attrs)
     DS.addAttributes(*Attrs);
if (Tok.is(tok::kw_delete)) {
 
       if (Tok.is(tok::code_completion)) {
         Actions.CodeCompleteInitializer(getCurScope(), ThisDecl);
         Actions.FinalizeDeclaration(ThisDecl);
         cutOffParsing();
         return nullptr;
       }
 
-      ExprResult Init(ParseInitializer());
+      ExprResult Init;
+      {
+        auto TypeRAII = PreferredType.enterVariableInit(ThisDecl);
+        Init = ParseInitializer();
+      }
 
       // If this is the only decl in (possibly) range based for statement,
       // our best guess is that the user meant ':' instead of '='.
       if (Tok.is(tok::r_paren) && FRI && D.isFirstDeclarator()) {
         Diag(EqualLoc, diag::err_single_decl_assign_in_for_range)
             << FixItHint::CreateReplacement(EqualLoc, ":");
         // We are trying to stop parser from looking for ';' in this for
         // statement, therefore preventing spurious errors to be issued.

lib/Parse/ParseDeclCXX.cpp

 ///
 /// 'decltype' ( expression )
 /// 'decltype' ( 'auto' )      [C++1y]
 ///
 SourceLocation Parser::ParseDecltypeSpecifier(DeclSpec &DS) {
   assert(Tok.isOneOf(tok::kw_decltype, tok::annot_decltype)
            && "Not a decltype specifier");
 
+  auto TypeRAII = PreferredType.enterUnknown();
+
   ExprResult Result;
   SourceLocation StartLoc = Tok.getLocation();
   SourceLocation EndLoc;
 
   if (Tok.is(tok::annot_decltype)) {
     Result = getExprAnnotation(Tok);
     EndLoc = Tok.getAnnotationEndLoc();
     ConsumeAnnotationToken();

lib/Parse/ParseExpr.cpp

LHS = Actions.ActOnUnaryOp(getCurScope(), ExtLoc, tok::kw___extension__,
                                LHS.get());
 
   return ParseRHSOfBinaryExpression(LHS, prec::Comma);
 }
 
 /// Parse an expr that doesn't include (top-level) commas.
 ExprResult Parser::ParseAssignmentExpression(TypeCastState isTypeCast) {
   if (Tok.is(tok::code_completion)) {
-    Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Expression);
+    Actions.CodeCompleteExpression(getCurScope(), PreferredType.get());
     cutOffParsing();
     return ExprError();
   }
 
   if (Tok.is(tok::kw_throw))
     return ParseThrowExpression();
   if (Tok.is(tok::kw_co_yield))
     return ParseCoyieldExpression();
if (NextTokPrec == prec::Conditional) {
 
         Diag(Tok, diag::err_expected)
             << tok::colon << FixItHint::CreateInsertion(FILoc, FIText);
         Diag(OpToken, diag::note_matching) << tok::question;
         ColonLoc = Tok.getLocation();
       }
     }
 
-    // Code completion for the right-hand side of a binary expression goes
-    // through a special hook that takes the left-hand side into account.
-    if (Tok.is(tok::code_completion)) {
-      Actions.CodeCompleteBinaryRHS(getCurScope(), LHS.get(),
-                                    OpToken.getKind());
-      cutOffParsing();
-      return ExprError();
-    }
-
+    auto TypeRAII =
+        PreferredType.enterBinary(Actions, LHS.get(), OpToken.getKind());
     // Parse another leaf here for the RHS of the operator.
     // ParseCastExpression works here because all RHS expressions in C have it
     // as a prefix, at least. However, in C++, an assignment-expression could
     // be a throw-expression, which is not a valid cast-expression.
     // Therefore we need some special-casing here.
     // Also note that the third operand of the conditional operator is
     // an assignment-expression in C++, and in C++11, we can have a
     // braced-init-list on the RHS of an assignment. For better diagnostics,
#undef RTT_JOIN
   case tok::plusplus:      // unary-expression: '++' unary-expression [C99]
   case tok::minusminus: {  // unary-expression: '--' unary-expression [C99]
     // C++ [expr.unary] has:
     //   unary-expression:
     //     ++ cast-expression
     //     -- cast-expression
     Token SavedTok = Tok;
     ConsumeToken();
+
+    auto TypeRAII = PreferredType.enterUnary(Actions, SavedTok.getKind());
     // One special case is implicitly handled here: if the preceding tokens are
     // an ambiguous cast expression, such as "(T())++", then we recurse to
     // determine whether the '++' is prefix or postfix.
     Res = ParseCastExpression(!getLangOpts().CPlusPlus,
                               /*isAddressOfOperand*/false, NotCastExpr,
                               NotTypeCast);
     if (NotCastExpr) {
       // If we return with NotCastExpr = true, we must not consume any tokens,
       // so put the token back where we found it.
       assert(Res.isInvalid());
       UnconsumeToken(SavedTok);
       return ExprError();
     }
     if (!Res.isInvalid())
       Res = Actions.ActOnUnaryOp(getCurScope(), SavedTok.getLocation(),
                                  SavedKind, Res.get());
     return Res;
   }
   case tok::amp: {         // unary-expression: '&' cast-expression
+    auto TypeRAII = PreferredType.enterUnary(Actions, tok::amp);
     // Special treatment because of member pointers
     SourceLocation SavedLoc = ConsumeToken();
     Res = ParseCastExpression(false, true);
     if (!Res.isInvalid())
       Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get());
     return Res;
   }
 
   case tok::star:          // unary-expression: '*' cast-expression
   case tok::plus:          // unary-expression: '+' cast-expression
   case tok::minus:         // unary-expression: '-' cast-expression
   case tok::tilde:         // unary-expression: '~' cast-expression
   case tok::exclaim:       // unary-expression: '!' cast-expression
   case tok::kw___real:     // unary-expression: '__real' cast-expression [GNU]
   case tok::kw___imag: {   // unary-expression: '__imag' cast-expression [GNU]
+    auto TypeRAII = PreferredType.enterUnary(Actions, Tok.getKind());
+
     SourceLocation SavedLoc = ConsumeToken();
     Res = ParseCastExpression(false);
     if (!Res.isInvalid())
       Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get());
     return Res;
   }
 
   case tok::kw_co_await: {  // unary-expression: 'co_await' cast-expression
     SourceLocation CoawaitLoc = ConsumeToken();
     Res = ParseCastExpression(false);
     if (!Res.isInvalid())
       Res = Actions.ActOnCoawaitExpr(getCurScope(), CoawaitLoc, Res.get());
     return Res;
   }
 
   case tok::kw___extension__:{//unary-expression:'__extension__' cast-expr [GNU]
case tok::kw__Alignof:   // unary-expression: '_Alignof' '(' type-name ')'
     LLVM_FALLTHROUGH;
   case tok::kw_alignof:    // unary-expression: 'alignof' '(' type-id ')'
   case tok::kw___alignof:  // unary-expression: '__alignof' unary-expression
                            // unary-expression: '__alignof' '(' type-name ')'
   case tok::kw_sizeof:     // unary-expression: 'sizeof' unary-expression
                            // unary-expression: 'sizeof' '(' type-name ')'
   case tok::kw_vec_step:   // unary-expression: OpenCL 'vec_step' expression
   // unary-expression: '__builtin_omp_required_simd_align' '(' type-name ')'
-  case tok::kw___builtin_omp_required_simd_align:
+  case tok::kw___builtin_omp_required_simd_align: {
+    auto TypeRAII = PreferredType.enterUnknown();
     return ParseUnaryExprOrTypeTraitExpression();
+  }
   case tok::ampamp: {      // unary-expression: '&&' identifier
+    auto TypeRAII = PreferredType.enterUnknown();
+
     SourceLocation AmpAmpLoc = ConsumeToken();
     if (Tok.isNot(tok::identifier))
       return ExprError(Diag(Tok, diag::err_expected) << tok::identifier);
 
     if (getCurScope()->getFnParent() == nullptr)
       return ExprError(Diag(Tok, diag::err_address_of_label_outside_fn));
 
     Diag(AmpAmpLoc, diag::ext_gnu_address_of_label);
#include "clang/Basic/OpenCLImageTypes.def"
   case tok::kw_delete: // [C++] delete-expression
     return ParseCXXDeleteExpression(false, Tok.getLocation());
 
   case tok::kw_noexcept: { // [C++0x] 'noexcept' '(' expression ')'
     Diag(Tok, diag::warn_cxx98_compat_noexcept_expr);
     SourceLocation KeyLoc = ConsumeToken();
     BalancedDelimiterTracker T(*this, tok::l_paren);
 
+    auto TypeRAII = PreferredType.enterUnknown();
     if (T.expectAndConsume(diag::err_expected_lparen_after, "noexcept"))
       return ExprError();
     // C++11 [expr.unary.noexcept]p1:
     //   The noexcept operator determines whether the evaluation of its operand,
     //   which is an unevaluated operand, can throw an exception.
     EnterExpressionEvaluationContext Unevaluated(
         Actions, Sema::ExpressionEvaluationContext::Unevaluated);
     ExprResult Result = ParseExpression();
#include "clang/Basic/TokenKinds.def"
   case tok::at: {
     SourceLocation AtLoc = ConsumeToken();
     return ParseObjCAtExpression(AtLoc);
   }
   case tok::caret:
     Res = ParseBlockLiteralExpression();
     break;
   case tok::code_completion: {
-    Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Expression);
+    Actions.CodeCompleteExpression(getCurScope(), PreferredType.get());
     cutOffParsing();
     return ExprError();
   }
   case tok::l_square:
     if (getLangOpts().CPlusPlus11) {
       if (getLangOpts().ObjC) {
         // C++11 lambda expressions and Objective-C message sends both start with a
         // square bracket.  There are three possibilities here:
Parser::ParsePostfixExpressionSuffix(ExprResult LHS) {
   // parsed, see if there are any postfix-expression pieces here.
   SourceLocation Loc;
   while (1) {
     switch (Tok.getKind()) {
     case tok::code_completion:
       if (InMessageExpression)
         return LHS;
 
-      Actions.CodeCompletePostfixExpression(getCurScope(), LHS);
+      Actions.CodeCompletePostfixExpression(getCurScope(), LHS,
+                                            PreferredType.get());
       cutOffParsing();
       return ExprError();
 
     case tok::identifier:
       // If we see identifier: after an expression, and we're not already in a
       // message send, then this is probably a message send with a missing
       // opening bracket '['.
       if (getLangOpts().ObjC && !InMessageExpression &&
case tok::l_square: {  // postfix-expression: p-e '[' expression ']'
 
       // Reject array indices starting with a lambda-expression. '[[' is
       // reserved for attributes.
       if (CheckProhibitedCXX11Attribute()) {
         (void)Actions.CorrectDelayedTyposInExpr(LHS);
         return ExprError();
       }
 
+      auto TypeRAII = PreferredType.enterSubscript(Actions, LHS.get());
+
       BalancedDelimiterTracker T(*this, tok::l_square);
       T.consumeOpen();
       Loc = T.getOpenLocation();
       ExprResult Idx, Length;
       SourceLocation ColonLoc;
       if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
         Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
         Idx = ParseBraceInitializer();
case tok::period: {
         Expr *Base = LHS.get();
         Expr *CorrectedBase = CorrectedLHS.get();
         if (!CorrectedBase && !getLangOpts().CPlusPlus)
           CorrectedBase = Base;
 
         // Code completion for a member access expression.
         Actions.CodeCompleteMemberReferenceExpr(
             getCurScope(), Base, CorrectedBase, OpLoc, OpKind == tok::arrow,
-            Base && ExprStatementTokLoc == Base->getBeginLoc());
+            Base && ExprStatementTokLoc == Base->getBeginLoc(),
+            PreferredType.get());
 
         cutOffParsing();
         return ExprError();
       }
 
       if (MayBePseudoDestructor && !LHS.isInvalid()) {
         LHS = ParseCXXPseudoDestructor(LHS.get(), OpLoc, OpKind, SS,
                                        ObjectType);
if (T.consumeOpen())
     return ExprError();
   SourceLocation OpenLoc = T.getOpenLocation();
 
   ExprResult Result(true);
   bool isAmbiguousTypeId;
   CastTy = nullptr;
 
   if (Tok.is(tok::code_completion)) {
-    Actions.CodeCompleteOrdinaryName(getCurScope(),
-                 ExprType >= CompoundLiteral? Sema::PCC_ParenthesizedExpression
-                                            : Sema::PCC_Expression);
+    Actions.CodeCompleteExpression(getCurScope(), PreferredType.get(),
+                                   /*IsParenthesized=*/ExprType >=
+                                       CompoundLiteral);
     cutOffParsing();
     return ExprError();
   }
 
   // Diagnose use of bridge casts in non-arc mode.
   bool BridgeCast = (getLangOpts().ObjC &&
                      Tok.isOneOf(tok::kw___bridge,
                                  tok::kw___bridge_transfer,
else {
         Diag(BridgeKeywordLoc, diag::err_arc_bridge_retain)
           << FixItHint::CreateReplacement(BridgeKeywordLoc,
                                           "__bridge_retained");
     }
 
     TypeResult Ty = ParseTypeName();
     T.consumeClose();
     ColonProtection.restore();
+
+    auto TypeRAII = PreferredType.enterTypeCast(Ty.get().get());
+
     RParenLoc = T.getCloseLocation();
     ExprResult SubExpr = ParseCastExpression(/*isUnaryExpression=*/false);
 
     if (Ty.isInvalid() || SubExpr.isInvalid())
       return ExprError();
 
     return Actions.ActOnObjCBridgedCast(getCurScope(), OpenLoc, Kind,
                                         BridgeKeywordLoc, Ty.get(),
if (!DeclaratorInfo.isInvalidType() && Tok.is(tok::identifier) &&
             Tok.getIdentifierInfo() == Ident_super &&
             getCurScope()->isInObjcMethodScope() &&
             GetLookAheadToken(1).isNot(tok::period)) {
           Diag(Tok.getLocation(), diag::err_illegal_super_cast)
             << SourceRange(OpenLoc, RParenLoc);
           return ExprError();
         }
 
+        auto TypeRAII = PreferredType.enterTypeCast(CastTy.get());
         // Parse the cast-expression that follows it next.
         // TODO: For cast expression with CastTy.
         Result = ParseCastExpression(/*isUnaryExpression=*/false,
                                      /*isAddressOfOperand=*/false,
                                      /*isTypeCast=*/IsTypeCast);
         if (!Result.isInvalid()) {
           Result = Actions.ActOnCastExpr(getCurScope(), OpenLoc,
                                          DeclaratorInfo, CastTy,

 ///
 /// [C++0x] initializer-clause:
 /// [C++0x]   assignment-expression
 /// [C++0x]   braced-init-list
 /// \endverbatim
 bool Parser::ParseExpressionList(SmallVectorImpl<Expr *> &Exprs,
                                  SmallVectorImpl<SourceLocation> &CommaLocs,
                                  llvm::function_ref<void()> Completer) {
+  auto TypeRAII = PreferredType.enterUnknown();
+
   bool SawError = false;
   while (1) {
     if (Tok.is(tok::code_completion)) {
       if (Completer)
         Completer();
       else
-        Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Expression);
+        Actions.CodeCompleteExpression(getCurScope(), PreferredType.get());
       cutOffParsing();
       return true;
     }
 
     ExprResult Expr;
     if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
       Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
       Expr = ParseBraceInitializer();

lib/Parse/ParseExprCXX.cpp

 ///         '&' identifier initializer
 ///
 ///       lambda-declarator:
 ///         '(' parameter-declaration-clause ')' attribute-specifier[opt]
 ///           'mutable'[opt] exception-specification[opt]
 ///           trailing-return-type[opt]
 ///
 ExprResult Parser::ParseLambdaExpression() {
+  auto TypeRAII = PreferredType.enterUnknown();
   // Parse lambda-introducer.
   LambdaIntroducer Intro;
   Optional<unsigned> DiagID = ParseLambdaIntroducer(Intro);
   if (DiagID) {
     Diag(Tok, DiagID.getValue());
     SkipUntil(tok::r_square, StopAtSemi);
     SkipUntil(tok::l_brace, StopAtSemi);
     SkipUntil(tok::r_brace, StopAtSemi);

 ///
 ///       postfix-expression: [C++ 5.2p1]
 ///         'typeid' '(' expression ')'
 ///         'typeid' '(' type-id ')'
 ///
 ExprResult Parser::ParseCXXTypeid() {
   assert(Tok.is(tok::kw_typeid) && "Not 'typeid'!");
 
+  auto TypeRAII = PreferredType.enterUnknown();
+
   SourceLocation OpLoc = ConsumeToken();
   SourceLocation LParenLoc, RParenLoc;
   BalancedDelimiterTracker T(*this, tok::l_paren);
 
   // typeid expressions are always parenthesized.
   if (T.expectAndConsume(diag::err_expected_lparen_after, "typeid"))
     return ExprError();
   LParenLoc = T.getOpenLocation();

 /// ParseCXXUuidof - This handles the Microsoft C++ __uuidof expression.
 ///
 ///         '__uuidof' '(' expression ')'
 ///         '__uuidof' '(' type-id ')'
 ///
 ExprResult Parser::ParseCXXUuidof() {
   assert(Tok.is(tok::kw___uuidof) && "Not '__uuidof'!");
 
+  auto TypeRAII = PreferredType.enterUnknown();
+
   SourceLocation OpLoc = ConsumeToken();
   BalancedDelimiterTracker T(*this, tok::l_paren);
 
   // __uuidof expressions are always parenthesized.
   if (T.expectAndConsume(diag::err_expected_lparen_after, "__uuidof"))
     return ExprError();
 
   ExprResult Result;
ExprResult Parser::ParseThrowExpression() {
   case tok::semi:
   case tok::r_paren:
   case tok::r_square:
   case tok::r_brace:
   case tok::colon:
   case tok::comma:
     return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, nullptr);
 
-  default:
+  default: {
+    auto TypeRAII = PreferredType.enterUnknown();
+
     ExprResult Expr(ParseAssignmentExpression());
-    if (Expr.isInvalid()) return Expr;
+    if (Expr.isInvalid())
+      return Expr;
     return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, Expr.get());
   }
   }
+}
 
 /// Parse the C++ Coroutines co_yield expression.
 ///
 ///       co_yield-expression:
 ///         'co_yield' assignment-expression[opt]
 ExprResult Parser::ParseCoyieldExpression() {
   assert(Tok.is(tok::kw_co_yield) && "Not co_yield!");
 
+  auto TypeRAII = PreferredType.enterUnknown();
+
   SourceLocation Loc = ConsumeToken();
   ExprResult Expr = Tok.is(tok::l_brace) ? ParseBraceInitializer()
                                          : ParseAssignmentExpression();
   if (!Expr.isInvalid())
     Expr = Actions.ActOnCoyieldExpr(getCurScope(), Loc, Expr.get());
   return Expr;
 }
 

 /// [C++0x] typename-specifier braced-init-list
 ///
 /// In C++1z onwards, the type specifier can also be a template-name.
 ExprResult
 Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
   Declarator DeclaratorInfo(DS, DeclaratorContext::FunctionalCastContext);
   ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get();
 
+  auto TypeRAII = PreferredType.enterTypeCast(TypeRep.get());
+
   assert((Tok.is(tok::l_paren) ||
           (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)))
          && "Expected '(' or '{'!");
 
   if (Tok.is(tok::l_brace)) {
     ExprResult Init = ParseBraceInitializer();
     if (Init.isInvalid())
       return Init;

 /// present will be parsed and stored here, and a null result will be returned.
 ///
 /// \returns The parsed condition.
 Sema::ConditionResult Parser::ParseCXXCondition(StmtResult *InitStmt,
                                                 SourceLocation Loc,
                                                 Sema::ConditionKind CK,
                                                 ForRangeInfo *FRI) {
   ParenBraceBracketBalancer BalancerRAIIObj(*this);
+  auto TypeRAII = PreferredType.enterCondition(Actions);
 
   if (Tok.is(tok::code_completion)) {
     Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Condition);
     cutOffParsing();
     return Sema::ConditionError();
   }
 
   ParsedAttributesWithRange attrs(AttrFactory);
if (CopyInitialization)
     ConsumeToken();
 
   ExprResult InitExpr = ExprError();
   if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
     Diag(Tok.getLocation(),
          diag::warn_cxx98_compat_generalized_initializer_lists);
     InitExpr = ParseBraceInitializer();
   } else if (CopyInitialization) {
+    auto TypeRAII = PreferredType.enterVariableInit(DeclOut);
     InitExpr = ParseAssignmentExpression();
   } else if (Tok.is(tok::l_paren)) {
     // This was probably an attempt to initialize the variable.
     SourceLocation LParen = ConsumeParen(), RParen = LParen;
     if (SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch))
       RParen = ConsumeParen();
     Diag(DeclOut->getLocation(),
          diag::err_expected_init_in_condition_lparen)

 ///        delete-expression:
 ///                   '::'[opt] 'delete' cast-expression
 ///                   '::'[opt] 'delete' '[' ']' cast-expression
 ExprResult
 Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) {
   assert(Tok.is(tok::kw_delete) && "Expected 'delete' keyword");
   ConsumeToken(); // Consume 'delete'
 
+  auto TypeRAII = PreferredType.enterUnknown();
   // Array delete?
   bool ArrayDelete = false;
   if (Tok.is(tok::l_square) && NextToken().is(tok::r_square)) {
     // C++11 [expr.delete]p1:
     //   Whenever the delete keyword is followed by empty square brackets, it
     //   shall be interpreted as [array delete].
     //   [Footnote: A lambda expression with a lambda-introducer that consists
     //              of empty square brackets can follow the delete keyword if

 ///          unary-type-trait '(' type-id ')'
 ///          binary-type-trait '(' type-id ',' type-id ')'
 ///          type-trait '(' type-id-seq ')'
 ///
 ///       type-id-seq:
 ///          type-id ...[opt] type-id-seq[opt]
 ///
 ExprResult Parser::ParseTypeTrait() {
+  auto TypeRAII = PreferredType.enterUnknown();
+
   tok::TokenKind Kind = Tok.getKind();
   unsigned Arity = TypeTraitArity(Kind);
 
   SourceLocation Loc = ConsumeToken();
 
   BalancedDelimiterTracker Parens(*this, tok::l_paren);
   if (Parens.expectAndConsume())
     return ExprError();

 /// ParseArrayTypeTrait - Parse the built-in array type-trait
 /// pseudo-functions.
 ///
 ///       primary-expression:
 /// [Embarcadero]     '__array_rank' '(' type-id ')'
 /// [Embarcadero]     '__array_extent' '(' type-id ',' expression ')'
 ///
 ExprResult Parser::ParseArrayTypeTrait() {
+  auto TypeRAII = PreferredType.enterUnknown();
+
   ArrayTypeTrait ATT = ArrayTypeTraitFromTokKind(Tok.getKind());
   SourceLocation Loc = ConsumeToken();
 
   BalancedDelimiterTracker T(*this, tok::l_paren);
   if (T.expectAndConsume())
     return ExprError();
 
   TypeResult Ty = ParseTypeName();

 
 /// ParseExpressionTrait - Parse built-in expression-trait
 /// pseudo-functions like __is_lvalue_expr( xxx ).
 ///
 ///       primary-expression:
 /// [Embarcadero]     expression-trait '(' expression ')'
 ///
 ExprResult Parser::ParseExpressionTrait() {
+  auto TypeRAII = PreferredType.enterUnknown();
+
   ExpressionTrait ET = ExpressionTraitFromTokKind(Tok.getKind());
   SourceLocation Loc = ConsumeToken();
 
   BalancedDelimiterTracker T(*this, tok::l_paren);
   if (T.expectAndConsume())
     return ExprError();
 
   ExprResult Expr = ParseExpression();

lib/Parse/ParseInit.cpp

 ///         '{' initializer-list ',' '}'
 /// [GNU]   '{' '}'
 ///
 ///       initializer-list:
 ///         designation[opt] initializer ...[opt]
 ///         initializer-list ',' designation[opt] initializer ...[opt]
 ///
 ExprResult Parser::ParseBraceInitializer() {
+  auto TypeRAII = PreferredType.enterUnknown();
+
   InMessageExpressionRAIIObject InMessage(*this, false);
 
   BalancedDelimiterTracker T(*this, tok::l_brace);
   T.consumeOpen();
   SourceLocation LBraceLoc = T.getOpenLocation();
 
   /// InitExprs - This is the actual list of expressions contained in the
   /// initializer.

lib/Parse/ParseStmt.cpp

 StmtResult Parser::ParseReturnStatement() {
   assert((Tok.is(tok::kw_return) || Tok.is(tok::kw_co_return)) &&
          "Not a return stmt!");
   bool IsCoreturn = Tok.is(tok::kw_co_return);
   SourceLocation ReturnLoc = ConsumeToken();  // eat the 'return'.
 
   ExprResult R;
   if (Tok.isNot(tok::semi)) {
+    auto TypeRAII = IsCoreturn ? PreferredType.enterUnknown()
+                               : PreferredType.enterReturn(Actions);
     // FIXME: Code completion for co_return.
     if (Tok.is(tok::code_completion) && !IsCoreturn) {
-      Actions.CodeCompleteReturn(getCurScope());
+      Actions.CodeCompleteExpression(getCurScope(), PreferredType.get());
       cutOffParsing();
       return StmtError();
     }
 
     if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus) {
       R = ParseInitializer();
       if (R.isUsable())
         Diag(R.get()->getBeginLoc(),

lib/Parse/ParseTemplate.cpp

 /// ParseTemplateArgumentList - Parse a C++ template-argument-list
 /// (C++ [temp.names]). Returns true if there was an error.
 ///
 ///       template-argument-list: [C++ 14.2]
 ///         template-argument
 ///         template-argument-list ',' template-argument
 bool
 Parser::ParseTemplateArgumentList(TemplateArgList &TemplateArgs) {
+  auto TypeRAII = PreferredType.enterUnknown();
 
   ColonProtectionRAIIObject ColonProtection(*this, false);
 
   do {
     ParsedTemplateArgument Arg = ParseTemplateArgument();
     SourceLocation EllipsisLoc;
     if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
       Arg = Actions.ActOnPackExpansion(Arg, EllipsisLoc);

lib/Sema/SemaCodeComplete.cpp

public:
   bool IsObjCMessageReceiver(const NamedDecl *ND) const;
   bool IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const;
   bool IsObjCCollection(const NamedDecl *ND) const;
   bool IsImpossibleToSatisfy(const NamedDecl *ND) const;
   //@}
 };
 } // namespace
 
+PreferredTypeBuilder::RestoreRAII
+PreferredTypeBuilder::update(llvm::function_ref<void()> Updater) {
+  RestoreRAII R(*this);
+  Updater();
+  return R;
+}
+
+PreferredTypeBuilder::RestoreRAII PreferredTypeBuilder::enterReturn(Sema &S) {
+  return update([&]() {
+    if (isa<BlockDecl>(S.CurContext)) {
+      if (sema::BlockScopeInfo *BSI = S.getCurBlock())
+        Type = BSI->ReturnType;
+      return;
+    }
+    if (const auto *Function = dyn_cast<FunctionDecl>(S.CurContext)) {
+      Type = Function->getReturnType();
+      return;
+    }
+    if (const auto *Method = dyn_cast<ObjCMethodDecl>(S.CurContext)) {
+      Type = Method->getReturnType();
+      return;
+    }
+    Type = QualType();
+  });
+}
+
+PreferredTypeBuilder::RestoreRAII
+PreferredTypeBuilder::enterVariableInit(Decl *D) {
+  return update([&]() {
+    auto *VD = llvm::dyn_cast_or_null<ValueDecl>(D);
+    Type = VD ? VD->getType() : QualType();
+  });
+}
+
+static QualType getPreferredTypeOfBinaryRHS(Sema &S, Expr *LHS,
+                                            tok::TokenKind Op) {
+  if (!LHS)
+    return QualType();
+
+  QualType LHSType = LHS->getType();
+  if (LHSType->isPointerType()) {
+    if (Op == tok::plus || Op == tok::plusequal || Op == tok::minusequal)
+      return S.getASTContext().getPointerDiffType();
+    // Pointer difference is more common than subtracting an int from a pointer.
+    if (Op == tok::minus)
+      return LHSType;
+  }
+
+  switch (Op) {
+  // No way to infer the type of RHS from LHS.
+  case tok::comma:
+    return QualType();
+  // Prefer the type of the left operand for all of these.
+  // Arithmetic operations.
+  case tok::plus:
+  case tok::plusequal:
+  case tok::minus:
+  case tok::minusequal:
+  case tok::percent:
+  case tok::percentequal:
+  case tok::slash:
+  case tok::slashequal:
+  case tok::star:
+  case tok::starequal:
+  // Assignment.
+  case tok::equal:
+  // Comparison operators.
+  case tok::equalequal:
+  case tok::exclaimequal:
+  case tok::less:
+  case tok::lessequal:
+  case tok::greater:
+  case tok::greaterequal:
+  case tok::spaceship:
+    return LHS->getType();
+  // Binary shifts are often overloaded, so don't try to guess those.
+  case tok::greatergreater:
+  case tok::greatergreaterequal:
+  case tok::lessless:
+  case tok::lesslessequal:
+    if (LHSType->isIntegralOrEnumerationType())
+      return S.getASTContext().IntTy;
+    return QualType();
+  // Logical operators, assume we want bool.
+  case tok::ampamp:
+  case tok::pipepipe:
+  case tok::caretcaret:
+    return S.getASTContext().BoolTy;
+  // Operators often used for bit manipulation are typically used with the type
+  // of the left argument.
+  case tok::pipe:
+  case tok::pipeequal:
+  case tok::caret:
+  case tok::caretequal:
+  case tok::amp:
+  case tok::ampequal:
+    if (LHSType->isIntegralOrEnumerationType())
+      return LHSType;
+    return QualType();
+  // RHS should be a pointer to a member of the 'LHS' type, but we can't give
+  // any particular type here.
+  case tok::periodstar:
+  case tok::arrowstar:
+    return QualType();
+  default:
+    // FIXME(ibiryukov): handle the missing op, re-add the assertion.
+    // assert(false && "unhandled binary op");
+    return QualType();
+  }
+}
+
+PreferredTypeBuilder::RestoreRAII
+PreferredTypeBuilder::enterBinary(Sema &S, Expr *LHS, tok::TokenKind Op) {
+  return update([&] { Type = getPreferredTypeOfBinaryRHS(S, LHS, Op); });
+}
+
+PreferredTypeBuilder::RestoreRAII
+PreferredTypeBuilder::enterUnary(Sema &S, tok::TokenKind Op) {
+  return update([&] {
+    switch (Op) {
+    case tok::exclaim:
+      Type = S.getASTContext().BoolTy;
+      break;
+    case tok::amp:
+      if (!Type.isNull() && Type->isPointerType())
+        Type = Type->getPointeeType();
+      else
+        Type = QualType();
+      break;
+    case tok::star:
+      if (Type.isNull())
+        break;
+      Type = S.getASTContext().getPointerType(Type.getNonReferenceType());
+      break;
+    case tok::plus:
+    case tok::minus:
+    case tok::tilde:
+    case tok::minusminus:
+    case tok::plusplus:
+      if (Type.isNull())
+        Type = S.getASTContext().IntTy;
+      // else leave as is, these operators typically return the same type.
+      break;
+    case tok::kw___real:
+    case tok::kw___imag:
+      Type = QualType();
+      break;
+    default:
+      assert(false && "unhnalded unary op");
+      Type = QualType();
+      break;
+    }
+  });
+}
+
+PreferredTypeBuilder::RestoreRAII
+PreferredTypeBuilder::enterSubscript(Sema &S, Expr *LHS) {
+  return update([&]() { Type = S.getASTContext().IntTy; });
+}
+
+PreferredTypeBuilder::RestoreRAII
+PreferredTypeBuilder::enterTypeCast(QualType CastType) {
+  return update([&] { Type = CastType; });
+}
+
+PreferredTypeBuilder::RestoreRAII PreferredTypeBuilder::enterUnknown() {
+  return update([&] { Type = QualType(); });
+}
+
+PreferredTypeBuilder::RestoreRAII
+PreferredTypeBuilder::enterCondition(Sema &S) {
+  return update([&] { Type = S.getASTContext().BoolTy; });
+}
+
 class ResultBuilder::ShadowMapEntry::iterator {
   llvm::PointerUnion<const NamedDecl *, const DeclIndexPair *> DeclOrIterator;
   unsigned SingleDeclIndex;
 
 public:
   typedef DeclIndexPair value_type;
   typedef value_type reference;
   typedef std::ptrdiff_t difference_type;
void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
   // Note that we intentionally suppress macro results here, since we do not
   // encourage using macros to produce the names of entities.
 
   HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
                             Results.data(), Results.size());
 }
 
 struct Sema::CodeCompleteExpressionData {
-  CodeCompleteExpressionData(QualType PreferredType = QualType())
+  CodeCompleteExpressionData(QualType PreferredType = QualType(),
+                             bool IsParenthesized = false)
       : PreferredType(PreferredType), IntegralConstantExpression(false),
-        ObjCCollection(false) {}
+        ObjCCollection(false), IsParenthesized(IsParenthesized) {}
 
   QualType PreferredType;
   bool IntegralConstantExpression;
   bool ObjCCollection;
+  bool IsParenthesized;
   SmallVector<Decl *, 4> IgnoreDecls;
 };
 
 /// Perform code-completion in an expression context when we know what
 /// type we're looking for.
 void Sema::CodeCompleteExpression(Scope *S,
                                   const CodeCompleteExpressionData &Data) {
   ResultBuilder Results(
       *this, CodeCompleter->getAllocator(),
       CodeCompleter->getCodeCompletionTUInfo(),
-      CodeCompletionContext(CodeCompletionContext::CCC_Expression,
-                            Data.PreferredType));
+      CodeCompletionContext(
+          Data.IsParenthesized
+              ? CodeCompletionContext::CCC_ParenthesizedExpression
+              : CodeCompletionContext::CCC_Expression,
+  auto PCC =
+      Data.IsParenthesized ? PCC_ParenthesizedExpression : PCC_Expression;
   if (Data.ObjCCollection)
     Results.setFilter(&ResultBuilder::IsObjCCollection);
   else if (Data.IntegralConstantExpression)
     Results.setFilter(&ResultBuilder::IsIntegralConstantValue);
-  else if (WantTypesInContext(PCC_Expression, getLangOpts()))
+  else if (WantTypesInContext(PCC, getLangOpts()))
     Results.setFilter(&ResultBuilder::IsOrdinaryName);
   else
     Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
 
   if (!Data.PreferredType.isNull())
     Results.setPreferredType(Data.PreferredType.getNonReferenceType());
 
   // Ignore any declarations that we were told that we don't care about.
   for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I)
     Results.Ignore(Data.IgnoreDecls[I]);
 
   CodeCompletionDeclConsumer Consumer(Results, CurContext);
   LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
                      CodeCompleter->includeGlobals(),
                      CodeCompleter->loadExternal());
 
   Results.EnterNewScope();
-  AddOrdinaryNameResults(PCC_Expression, S, *this, Results);
+  AddOrdinaryNameResults(PCC, S, *this, Results);
   Results.ExitScope();
 
   bool PreferredTypeIsPointer = false;
   if (!Data.PreferredType.isNull())
     PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType() ||
                              Data.PreferredType->isMemberPointerType() ||
                              Data.PreferredType->isBlockPointerType();
 
   if (S->getFnParent() && !Data.ObjCCollection &&
       !Data.IntegralConstantExpression)
     AddPrettyFunctionResults(getLangOpts(), Results);
 
   if (CodeCompleter->includeMacros())
     AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false,
                     PreferredTypeIsPointer);
   HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
                             Results.data(), Results.size());
 }
 
-void Sema::CodeCompleteExpression(Scope *S, QualType PreferredType) {
-  return CodeCompleteExpression(S, CodeCompleteExpressionData(PreferredType));
+void Sema::CodeCompleteExpression(Scope *S, QualType PreferredType,
+                                  bool IsParenthesized) {
+  return CodeCompleteExpression(
+      S, CodeCompleteExpressionData(PreferredType, IsParenthesized));
 }
 
-void Sema::CodeCompletePostfixExpression(Scope *S, ExprResult E) {
+void Sema::CodeCompletePostfixExpression(Scope *S, ExprResult E,
+                                         QualType PreferredType) {
   if (E.isInvalid())
-    CodeCompleteOrdinaryName(S, PCC_RecoveryInFunction);
+    CodeCompleteExpression(S, PreferredType);
   else if (getLangOpts().ObjC)
     CodeCompleteObjCInstanceMessage(S, E.get(), None, false);
 }
 
 /// The set of properties that have already been added, referenced by
 /// property name.
 typedef llvm::SmallPtrSet<IdentifierInfo *, 16> AddedPropertiesSet;
 
if (!Results.empty()) {
         Results.AddResult(CodeCompletionResult("template"));
     }
   }
 }
 
 void Sema::CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base,
                                            Expr *OtherOpBase,
                                            SourceLocation OpLoc, bool IsArrow,
-                                           bool IsBaseExprStatement) {
+                                           bool IsBaseExprStatement,
+                                           QualType PreferredType) {
   if (!Base || !CodeCompleter)
     return;
 
   ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
   if (ConvertedBase.isInvalid())
     return;
   QualType ConvertedBaseType = ConvertedBase.get()->getType();
 
if (ConvertedBaseType->isObjCObjectPointerType() ||
         ConvertedBaseType->isObjCObjectOrInterfaceType()) {
       contextKind = CodeCompletionContext::CCC_ObjCPropertyAccess;
     } else {
       contextKind = CodeCompletionContext::CCC_DotMemberAccess;
     }
   }
 
   CodeCompletionContext CCContext(contextKind, ConvertedBaseType);
+  CCContext.setPreferredType(PreferredType);
   ResultBuilder Results(*this, CodeCompleter->getAllocator(),
                         CodeCompleter->getCodeCompletionTUInfo(), CCContext,
                         &ResultBuilder::IsMember);
 
   auto DoCompletion = [&](Expr *Base, bool IsArrow,
                           Optional<FixItHint> AccessOpFixIt) -> bool {
     if (!Base)
       return false;
void Sema::CodeCompleteInitializer(Scope *S, Decl *D) {
   CodeCompleteExpressionData Data;
   Data.PreferredType = VD->getType();
   // Ignore VD to avoid completing the variable itself, e.g. in 'int foo = ^'.
   Data.IgnoreDecls.push_back(VD);
 
   CodeCompleteExpression(S, Data);
 }
 
-void Sema::CodeCompleteReturn(Scope *S) {
-  QualType ResultType;
-  if (isa<BlockDecl>(CurContext)) {
-    if (BlockScopeInfo *BSI = getCurBlock())
-      ResultType = BSI->ReturnType;
-  } else if (const auto *Function = dyn_cast<FunctionDecl>(CurContext))
-    ResultType = Function->getReturnType();
-  else if (const auto *Method = dyn_cast<ObjCMethodDecl>(CurContext))
-    ResultType = Method->getReturnType();
-
-  if (ResultType.isNull())
-    CodeCompleteOrdinaryName(S, PCC_Expression);
-  else
-    CodeCompleteExpression(S, ResultType);
-}
-
 void Sema::CodeCompleteAfterIf(Scope *S) {
   ResultBuilder Results(*this, CodeCompleter->getAllocator(),
                         CodeCompleter->getCodeCompletionTUInfo(),
                         mapCodeCompletionContext(*this, PCC_Statement));
   Results.setFilter(&ResultBuilder::IsOrdinaryName);
   Results.EnterNewScope();
 
   CodeCompletionDeclConsumer Consumer(Results, CurContext);
void Sema::CodeCompleteAfterIf(Scope *S) {
 
   if (CodeCompleter->includeMacros())
     AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false);
 
   HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
                             Results.data(), Results.size());
 }
 
-static QualType getPreferredTypeOfBinaryRHS(Sema &S, Expr *LHS,
-                                            tok::TokenKind Op) {
-  if (!LHS)
-    return QualType();
-
-  QualType LHSType = LHS->getType();
-  if (LHSType->isPointerType()) {
-    if (Op == tok::plus || Op == tok::plusequal || Op == tok::minusequal)
-      return S.getASTContext().getPointerDiffType();
-    // Pointer difference is more common than subtracting an int from a pointer.
-    if (Op == tok::minus)
-      return LHSType;
-  }
-
-  switch (Op) {
-  // No way to infer the type of RHS from LHS.
-  case tok::comma:
-    return QualType();
-  // Prefer the type of the left operand for all of these.
-  // Arithmetic operations.
-  case tok::plus:
-  case tok::plusequal:
-  case tok::minus:
-  case tok::minusequal:
-  case tok::percent:
-  case tok::percentequal:
-  case tok::slash:
-  case tok::slashequal:
-  case tok::star:
-  case tok::starequal:
-  // Assignment.
-  case tok::equal:
-  // Comparison operators.
-  case tok::equalequal:
-  case tok::exclaimequal:
-  case tok::less:
-  case tok::lessequal:
-  case tok::greater:
-  case tok::greaterequal:
-  case tok::spaceship:
-    return LHS->getType();
-  // Binary shifts are often overloaded, so don't try to guess those.
-  case tok::greatergreater:
-  case tok::greatergreaterequal:
-  case tok::lessless:
-  case tok::lesslessequal:
-    if (LHSType->isIntegralOrEnumerationType())
-      return S.getASTContext().IntTy;
-    return QualType();
-  // Logical operators, assume we want bool.
-  case tok::ampamp:
-  case tok::pipepipe:
-  case tok::caretcaret:
-    return S.getASTContext().BoolTy;
-  // Operators often used for bit manipulation are typically used with the type
-  // of the left argument.
-  case tok::pipe:
-  case tok::pipeequal:
-  case tok::caret:
-  case tok::caretequal:
-  case tok::amp:
-  case tok::ampequal:
-    if (LHSType->isIntegralOrEnumerationType())
-      return LHSType;
-    return QualType();
-  // RHS should be a pointer to a member of the 'LHS' type, but we can't give
-  // any particular type here.
-  case tok::periodstar:
-  case tok::arrowstar:
-    return QualType();
-  default:
-    // FIXME(ibiryukov): handle the missing op, re-add the assertion.
-    // assert(false && "unhandled binary op");
-    return QualType();
-  }
-}
-
-void Sema::CodeCompleteBinaryRHS(Scope *S, Expr *LHS, tok::TokenKind Op) {
-  auto PreferredType = getPreferredTypeOfBinaryRHS(*this, LHS, Op);
-  if (!PreferredType.isNull())
-    CodeCompleteExpression(S, PreferredType);
-  else
-    CodeCompleteOrdinaryName(S, PCC_Expression);
-}
-
 void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
                                    bool EnteringContext, QualType BaseType) {
   if (SS.isEmpty() || !CodeCompleter)
     return;
 
   // We want to keep the scope specifier even if it's invalid (e.g. the scope
   // "a::b::" is not corresponding to any context/namespace in the AST), since
   // it can be useful for global code completion which have information about

unittests/Sema/CodeCompleteTest.cpp

void test(Cls c) {
       // often overloaded with a non-standard meaning.
       c << ^c; c >> ^c; c | ^c; c & ^c;
       c <<= ^c; c >>= ^c; c |= ^c; c &= ^c;
     }
   )cpp";
   EXPECT_THAT(collectPreferredTypes(Code), Each("NULL TYPE"));
 }
 
+TEST(PreferredTypeTest, Members) {
+  StringRef Code = R"cpp(
+    struct vector {
+      int *begin();
+      vector clone();
+    };
+
+    void test(int *a) {
+      a = ^vector().^clone().^begin();
+    }
+  )cpp";
+  EXPECT_THAT(collectPreferredTypes(Code), Each("int *"));
+}
+
+TEST(PreferredTypeTest, Conditions) {
+  StringRef Code = R"cpp(
+    struct vector {
+      bool empty();
+    };
+
+    void test() {
+      if (^vector().^empty()) {}
+      while (^vector().^empty()) {}
+      for (; ^vector().^empty();) {}
+    }
+  )cpp";
+  EXPECT_THAT(collectPreferredTypes(Code), Each("_Bool"));
+}
+
+TEST(PreferredTypeTest, InitAndAssignment) {
+  StringRef Code = R"cpp(
+    struct vector {
+      int* begin();
+    };
+
+    void test() {
+      const int* x = ^vector().^begin();
+      x = ^vector().^begin();
+
+      if (const int* y = ^vector().^begin()) {}
+    }
+  )cpp";
+  EXPECT_THAT(collectPreferredTypes(Code), Each("const int *"));
+}
+
+TEST(PreferredTypeTest, UnaryExprs) {
+  StringRef Code = R"cpp(
+    void test(long long a) {
+      a = +^a;
+      a = -^a
+      a = ++^a;
+      a = --^a;
+    }
+  )cpp";
+  EXPECT_THAT(collectPreferredTypes(Code), Each("long long"));
+
+  Code = R"cpp(
+    void test(int a, int *ptr) {
+      !^a;
+      !^ptr;
+      !!!^a;
+
+      a = !^a;
+      a = !^ptr;
+      a = !!!^a;
+    }
+  )cpp";
+  EXPECT_THAT(collectPreferredTypes(Code), Each("_Bool"));
+
+  Code = R"cpp(
+    void test(int a) {
+      const int* x = &^a;
+    }
+  )cpp";
+  EXPECT_THAT(collectPreferredTypes(Code), Each("const int"));
+
+  Code = R"cpp(
+    void test(int *a) {
+      int x = *^a;
+      int &r = *^a;
+    }
+  )cpp";
+  EXPECT_THAT(collectPreferredTypes(Code), Each("int *"));
+
+  Code = R"cpp(
+    void test(int a) {
+      *^a;
+      &^a;
+    }
+
+  )cpp";
+}
 } // namespace