//===--- SemaExprCXX.cpp - Semantic Analysis for Expressions --------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

///

/// \file

/// Implements semantic analysis for C++ expressions.

///

//===----------------------------------------------------------------------===//

#include "TreeTransform.h"

#include "TypeLocBuilder.h"

#include "clang/AST/ASTContext.h"

#include "clang/AST/ASTLambda.h"

#include "clang/AST/CXXInheritance.h"

#include "clang/AST/CharUnits.h"

#include "clang/AST/DeclObjC.h"

#include "clang/AST/ExprCXX.h"

#include "clang/AST/ExprObjC.h"

#include "clang/AST/RecursiveASTVisitor.h"

#include "clang/AST/TypeLoc.h"

#include "clang/Basic/AlignedAllocation.h"

#include "clang/Basic/DiagnosticSema.h"

#include "clang/Basic/PartialDiagnostic.h"

#include "clang/Basic/TargetInfo.h"

#include "clang/Basic/TypeTraits.h"

#include "clang/Lex/Preprocessor.h"

#include "clang/Sema/DeclSpec.h"

#include "clang/Sema/Initialization.h"

#include "clang/Sema/Lookup.h"

#include "clang/Sema/ParsedTemplate.h"

#include "clang/Sema/Scope.h"

#include "clang/Sema/ScopeInfo.h"

#include "clang/Sema/SemaInternal.h"

#include "clang/Sema/SemaLambda.h"

#include "clang/Sema/Template.h"

#include "clang/Sema/TemplateDeduction.h"

#include "llvm/ADT/APInt.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/Support/ErrorHandling.h"

#include "llvm/Support/TypeSize.h"

using namespace clang;

using namespace sema;

/// Handle the result of the special case name lookup for inheriting

/// constructor declarations. 'NS::X::X' and 'NS::X<...>::X' are treated as

/// constructor names in member using declarations, even if 'X' is not the

/// name of the corresponding type.

ParsedType Sema::getInheritingConstructorName(CXXScopeSpec &SS,

                                              SourceLocation NameLoc,

                                              IdentifierInfo &Name) {

  NestedNameSpecifier *NNS = SS.getScopeRep();

  // Convert the nested-name-specifier into a type.

  QualType Type;

  switch (NNS->getKind()) {

  case NestedNameSpecifier::TypeSpec:

  case NestedNameSpecifier::TypeSpecWithTemplate:

    Type = QualType(NNS->getAsType(), 0);

    break;

  case NestedNameSpecifier::Identifier:

    // Strip off the last layer of the nested-name-specifier and build a

    // typename type for it.

    assert(NNS->getAsIdentifier() == &Name && "not a constructor name");

    Type = Context.getDependentNameType(ETK_None, NNS->getPrefix(),

                                        NNS->getAsIdentifier());

    break;

  case NestedNameSpecifier::Global:

  case NestedNameSpecifier::Super:

  case NestedNameSpecifier::Namespace:

  case NestedNameSpecifier::NamespaceAlias:

    llvm_unreachable("Nested name specifier is not a type for inheriting ctor");

  }

  // This reference to the type is located entirely at the location of the

  // final identifier in the qualified-id.

  return CreateParsedType(Type,

                          Context.getTrivialTypeSourceInfo(Type, NameLoc));

}

ParsedType Sema::getConstructorName(IdentifierInfo &II,

                                    SourceLocation NameLoc,

                                    Scope *S, CXXScopeSpec &SS,

                                    bool EnteringContext) {

  CXXRecordDecl *CurClass = getCurrentClass(S, &SS);

  assert(CurClass && &II == CurClass->getIdentifier() &&

         "not a constructor name");

  // When naming a constructor as a member of a dependent context (eg, in a

  // friend declaration or an inherited constructor declaration), form an

  // unresolved "typename" type.

  if (CurClass->isDependentContext() && 
!EnteringContext175k
 && 
SS.getScopeRep()3
) {

    QualType T = Context.getDependentNameType(ETK_None, SS.getScopeRep(), &II);

    return ParsedType::make(T);

  }

  if (SS.isNotEmpty() && 
RequireCompleteDeclContext(SS, CurClass)26.9k
)

    return ParsedType();

  // Find the injected-class-name declaration. Note that we make no attempt to

  // diagnose cases where the injected-class-name is shadowed: the only

  // declaration that can validly shadow the injected-class-name is a

  // non-static data member, and if the class contains both a non-static data

  // member and a constructor then it is ill-formed (we check that in

  // CheckCompletedCXXClass).

  CXXRecordDecl *InjectedClassName = nullptr;

  for (NamedDecl *ND : CurClass->lookup(&II)) {

    auto *RD = dyn_cast<CXXRecordDecl>(ND);

    if (RD && RD->isInjectedClassName()) {

      InjectedClassName = RD;

      break;

    }

  }

  if (!InjectedClassName) {

    if (!CurClass->isInvalidDecl()) {

      // FIXME: RequireCompleteDeclContext doesn't check dependent contexts

      // properly. Work around it here for now.

      Diag(SS.getLastQualifierNameLoc(),

           diag::err_incomplete_nested_name_spec) << CurClass << SS.getRange();

    }

    return ParsedType();

  }

  QualType T = Context.getTypeDeclType(InjectedClassName);

  DiagnoseUseOfDecl(InjectedClassName, NameLoc);

  MarkAnyDeclReferenced(NameLoc, InjectedClassName, /*OdrUse=*/false);

  return ParsedType::make(T);

}

ParsedType Sema::getDestructorName(SourceLocation TildeLoc,

                                   IdentifierInfo &II,

                                   SourceLocation NameLoc,

                                   Scope *S, CXXScopeSpec &SS,

                                   ParsedType ObjectTypePtr,

                                   bool EnteringContext) {

  // Determine where to perform name lookup.

  // FIXME: This area of the standard is very messy, and the current

  // wording is rather unclear about which scopes we search for the

  // destructor name; see core issues 399 and 555. Issue 399 in

  // particular shows where the current description of destructor name

  // lookup is completely out of line with existing practice, e.g.,

  // this appears to be ill-formed:

  //

  //   namespace N {

  //     template <typename T> struct S {

  //       ~S();

  //     };

  //   }

  //

  //   void f(N::S<int>* s) {

  //     s->N::S<int>::~S();

  //   }

  //

  // See also PR6358 and PR6359.

  //

  // For now, we accept all the cases in which the name given could plausibly

  // be interpreted as a correct destructor name, issuing off-by-default

  // extension diagnostics on the cases that don't strictly conform to the

  // C++20 rules. This basically means we always consider looking in the

  // nested-name-specifier prefix, the complete nested-name-specifier, and

  // the scope, and accept if we find the expected type in any of the three

  // places.

  if (SS.isInvalid())

    return nullptr;

  // Whether we've failed with a diagnostic already.

  bool Failed = false;

  llvm::SmallVector<NamedDecl*, 8> FoundDecls;

  llvm::SmallPtrSet<CanonicalDeclPtr<Decl>, 8> FoundDeclSet;

  // If we have an object type, it's because we are in a

  // pseudo-destructor-expression or a member access expression, and

  // we know what type we're looking for.

  QualType SearchType =

      ObjectTypePtr ? 
GetTypeFromParser(ObjectTypePtr)291
 : 
QualType()41.4k
;

  auto CheckLookupResult = [&](LookupResult &Found) -> ParsedType {

    auto IsAcceptableResult = [&](NamedDecl *D) -> bool {

      auto *Type = dyn_cast<TypeDecl>(D->getUnderlyingDecl());

      if (!Type)

        return false;

      if (SearchType.isNull() || 
SearchType->isDependentType()642
)

        return true;

      QualType T = Context.getTypeDeclType(Type);

      return Context.hasSameUnqualifiedType(T, SearchType);

    };

    unsigned NumAcceptableResults = 0;

    for (NamedDecl *D : Found) {

      if (IsAcceptableResult(D))

        ++NumAcceptableResults;

      // Don't list a class twice in the lookup failure diagnostic if it's

      // found by both its injected-class-name and by the name in the enclosing

      // scope.

      if (auto *RD = dyn_cast<CXXRecordDecl>(D))

        if (RD->isInjectedClassName())

          D = cast<NamedDecl>(RD->getParent());

      if (FoundDeclSet.insert(D).second)

        FoundDecls.push_back(D);

    }

    // As an extension, attempt to "fix" an ambiguity by erasing all non-type

    // results, and all non-matching results if we have a search type. It's not

    // clear what the right behavior is if destructor lookup hits an ambiguity,

    // but other compilers do generally accept at least some kinds of

    // ambiguity.

    if (Found.isAmbiguous() && 
NumAcceptableResults == 16
) {

      Diag(NameLoc, diag::ext_dtor_name_ambiguous);

      LookupResult::Filter F = Found.makeFilter();

      while (F.hasNext()) {

        NamedDecl *D = F.next();

        if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl()))

          Diag(D->getLocation(), diag::note_destructor_type_here)

              << Context.getTypeDeclType(TD);

        else

          Diag(D->getLocation(), diag::note_destructor_nontype_here);

        if (!IsAcceptableResult(D))

          F.erase();

      }

      F.done();

    }

    if (Found.isAmbiguous())

      Failed = true;

    if (TypeDecl *Type = Found.getAsSingle<TypeDecl>()) {

      if (IsAcceptableResult(Type)) {

        QualType T = Context.getTypeDeclType(Type);

        MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);

        return CreateParsedType(T,

                                Context.getTrivialTypeSourceInfo(T, NameLoc));

      }

    }

    return nullptr;

  };

  bool IsDependent = false;

  auto LookupInObjectType = [&]() -> ParsedType {

    if (Failed || SearchType.isNull())

      return nullptr;

    IsDependent |= SearchType->isDependentType();

    LookupResult Found(*this, &II, NameLoc, LookupDestructorName);

    DeclContext *LookupCtx = computeDeclContext(SearchType);

    if (!LookupCtx)

      return nullptr;

    LookupQualifiedName(Found, LookupCtx);

    return CheckLookupResult(Found);

  };

  auto LookupInNestedNameSpec = [&](CXXScopeSpec &LookupSS) -> ParsedType {

    if (Failed)

      return nullptr;

    IsDependent |= isDependentScopeSpecifier(LookupSS);

    DeclContext *LookupCtx = computeDeclContext(LookupSS, EnteringContext);

    if (!LookupCtx)

      return nullptr;

    LookupResult Found(*this, &II, NameLoc, LookupDestructorName);

    if (RequireCompleteDeclContext(LookupSS, LookupCtx)) {

      Failed = true;

      return nullptr;

    }

    LookupQualifiedName(Found, LookupCtx);

    return CheckLookupResult(Found);

  };

  auto LookupInScope = [&]() -> ParsedType {

    if (Failed || !S)

      return nullptr;

    LookupResult Found(*this, &II, NameLoc, LookupDestructorName);

    LookupName(Found, S);

    return CheckLookupResult(Found);

  };

  // C++2a [basic.lookup.qual]p6:

  //   In a qualified-id of the form

  //

  //     nested-name-specifier[opt] type-name :: ~ type-name

  //

  //   the second type-name is looked up in the same scope as the first.

  //

  // We interpret this as meaning that if you do a dual-scope lookup for the

  // first name, you also do a dual-scope lookup for the second name, per

  // C++ [basic.lookup.classref]p4:

  //

  //   If the id-expression in a class member access is a qualified-id of the

  //   form

  //

  //     class-name-or-namespace-name :: ...

  //

  //   the class-name-or-namespace-name following the . or -> is first looked

  //   up in the class of the object expression and the name, if found, is used.

  //   Otherwise, it is looked up in the context of the entire

  //   postfix-expression.

  //

  // This looks in the same scopes as for an unqualified destructor name:

  //

  // C++ [basic.lookup.classref]p3:

  //   If the unqualified-id is ~ type-name, the type-name is looked up

  //   in the context of the entire postfix-expression. If the type T

  //   of the object expression is of a class type C, the type-name is

  //   also looked up in the scope of class C. At least one of the

  //   lookups shall find a name that refers to cv T.

  //

  // FIXME: The intent is unclear here. Should type-name::~type-name look in

  // the scope anyway if it finds a non-matching name declared in the class?

  // If both lookups succeed and find a dependent result, which result should

  // we retain? (Same question for p->~type-name().)

  if (NestedNameSpecifier *Prefix =

      SS.isSet() ? SS.getScopeRep()->getPrefix() : nullptr) {

    // This is

    //

    //   nested-name-specifier type-name :: ~ type-name

    //

    // Look for the second type-name in the nested-name-specifier.

    CXXScopeSpec PrefixSS;

    PrefixSS.Adopt(NestedNameSpecifierLoc(Prefix, SS.location_data()));

    if (ParsedType T = LookupInNestedNameSpec(PrefixSS))

      return T;

  } else {

    // This is one of

    //

    //   type-name :: ~ type-name

    //   ~ type-name

    //

    // Look in the scope and (if any) the object type.

    if (ParsedType T = LookupInScope())

      return T;

    if (ParsedType T = LookupInObjectType())

      return T;

  }

  if (Failed)

    return nullptr;

  if (IsDependent) {

    // We didn't find our type, but that's OK: it's dependent anyway.

    // FIXME: What if we have no nested-name-specifier?

    QualType T = CheckTypenameType(ETK_None, SourceLocation(),

                                   SS.getWithLocInContext(Context),

                                   II, NameLoc);

    return ParsedType::make(T);

  }

  // The remaining cases are all non-standard extensions imitating the behavior

  // of various other compilers.

  unsigned NumNonExtensionDecls = FoundDecls.size();

  if (SS.isSet()) {

    // For compatibility with older broken C++ rules and existing code,

    //

    //   nested-name-specifier :: ~ type-name

    //

    // also looks for type-name within the nested-name-specifier.

    if (ParsedType T = LookupInNestedNameSpec(SS)) {

      Diag(SS.getEndLoc(), diag::ext_dtor_named_in_wrong_scope)

          << SS.getRange()

          << FixItHint::CreateInsertion(SS.getEndLoc(),

                                        ("::" + II.getName()).str());

      return T;

    }

    // For compatibility with other compilers and older versions of Clang,

    //

    //   nested-name-specifier type-name :: ~ type-name

    //

    // also looks for type-name in the scope. Unfortunately, we can't

    // reasonably apply this fallback for dependent nested-name-specifiers.

    if (SS.getScopeRep()->getPrefix()) {

      if (ParsedType T = LookupInScope()) {

        Diag(SS.getEndLoc(), diag::ext_qualified_dtor_named_in_lexical_scope)

            << FixItHint::CreateRemoval(SS.getRange());

        Diag(FoundDecls.back()->getLocation(), diag::note_destructor_type_here)

            << GetTypeFromParser(T);

        return T;

      }

    }

  }

  // We didn't find anything matching; tell the user what we did find (if

  // anything).

  // Don't tell the user about declarations we shouldn't have found.

  FoundDecls.resize(NumNonExtensionDecls);

  // List types before non-types.

  std::stable_sort(FoundDecls.begin(), FoundDecls.end(),

                   [](NamedDecl *A, NamedDecl *B) {

                     return isa<TypeDecl>(A->getUnderlyingDecl()) >

                            isa<TypeDecl>(B->getUnderlyingDecl());

                   });

  // Suggest a fixit to properly name the destroyed type.

  auto MakeFixItHint = [&]{

    const CXXRecordDecl *Destroyed = nullptr;

    // FIXME: If we have a scope specifier, suggest its last component?

    if (!SearchType.isNull())

      Destroyed = SearchType->getAsCXXRecordDecl();

    else if (S)

      Destroyed = dyn_cast_or_null<CXXRecordDecl>(S->getEntity());

    if (Destroyed)

      return FixItHint::CreateReplacement(SourceRange(NameLoc),

                                          Destroyed->getNameAsString());

    return FixItHint();

  };

  if (FoundDecls.empty()) {

    // FIXME: Attempt typo-correction?

    Diag(NameLoc, diag::err_undeclared_destructor_name)

      << &II << MakeFixItHint();

  } else 
if (23
!SearchType.isNull()23
 && 
FoundDecls.size() == 121
) {

    if (auto *TD = dyn_cast<TypeDecl>(FoundDecls[0]->getUnderlyingDecl())) {

      assert(!SearchType.isNull() &&

             "should only reject a type result if we have a search type");

      QualType T = Context.getTypeDeclType(TD);

      Diag(NameLoc, diag::err_destructor_expr_type_mismatch)

          << T << SearchType << MakeFixItHint();

    } else {

      Diag(NameLoc, diag::err_destructor_expr_nontype)

          << &II << MakeFixItHint();

    }

  } else {

    Diag(NameLoc, SearchType.isNull() ? diag::err_destructor_name_nontype

                                      : 
diag::err_destructor_expr_mismatch0
)

        << &II << SearchType << MakeFixItHint();

  }

  for (NamedDecl *FoundD : FoundDecls) {

    if (auto *TD = dyn_cast<TypeDecl>(FoundD->getUnderlyingDecl()))

      Diag(FoundD->getLocation(), diag::note_destructor_type_here)

          << Context.getTypeDeclType(TD);

    else

      Diag(FoundD->getLocation(), diag::note_destructor_nontype_here)

          << FoundD;

  }

  return nullptr;

}

ParsedType Sema::getDestructorTypeForDecltype(const DeclSpec &DS,

                                              ParsedType ObjectType) {

  if (DS.getTypeSpecType() == DeclSpec::TST_error)

    return nullptr;

  if (DS.getTypeSpecType() == DeclSpec::TST_decltype_auto) {

    Diag(DS.getTypeSpecTypeLoc(), diag::err_decltype_auto_invalid);

    return nullptr;

  }

  assert(DS.getTypeSpecType() == DeclSpec::TST_decltype &&

         "unexpected type in getDestructorType");

  QualType T = BuildDecltypeType(DS.getRepAsExpr());

  // If we know the type of the object, check that the correct destructor

  // type was named now; we can give better diagnostics this way.

  QualType SearchType = GetTypeFromParser(ObjectType);

  if (!SearchType.isNull() && 
!SearchType->isDependentType()18
 &&

      
!Context.hasSameUnqualifiedType(T, SearchType)18
) {

    Diag(DS.getTypeSpecTypeLoc(), diag::err_destructor_expr_type_mismatch)

      << T << SearchType;

    return nullptr;

  }

  return ParsedType::make(T);

}

bool Sema::checkLiteralOperatorId(const CXXScopeSpec &SS,

                                  const UnqualifiedId &Name, bool IsUDSuffix) {

  assert(Name.getKind() == UnqualifiedIdKind::IK_LiteralOperatorId);

  if (!IsUDSuffix) {

    // [over.literal] p8

    //

    // double operator""_Bq(long double);  // OK: not a reserved identifier

    // double operator"" _Bq(long double); // ill-formed, no diagnostic required

    IdentifierInfo *II = Name.Identifier;

    ReservedIdentifierStatus Status = II->isReserved(PP.getLangOpts());

    SourceLocation Loc = Name.getEndLoc();

    if (isReservedInAllContexts(Status) &&

        
!PP.getSourceManager().isInSystemHeader(Loc)2
) {

      Diag(Loc, diag::warn_reserved_extern_symbol)

          << II << static_cast<int>(Status)

          << FixItHint::CreateReplacement(

                 Name.getSourceRange(),

                 (StringRef("operator\"\"") + II->getName()).str());

    }

  }

  if (!SS.isValid())

    return false;

  switch (SS.getScopeRep()->getKind()) {

  case NestedNameSpecifier::Identifier:

  case NestedNameSpecifier::TypeSpec:

  case NestedNameSpecifier::TypeSpecWithTemplate:

    // Per C++11 [over.literal]p2, literal operators can only be declared at

    // namespace scope. Therefore, this unqualified-id cannot name anything.

    // Reject it early, because we have no AST representation for this in the

    // case where the scope is dependent.

    Diag(Name.getBeginLoc(), diag::err_literal_operator_id_outside_namespace)

        << SS.getScopeRep();

    return true;

  case NestedNameSpecifier::Global:

  case NestedNameSpecifier::Super:

  case NestedNameSpecifier::Namespace:

  case NestedNameSpecifier::NamespaceAlias:

    return false;

  }

  llvm_unreachable("unknown nested name specifier kind");

}

/// Build a C++ typeid expression with a type operand.

ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType,

                                SourceLocation TypeidLoc,

                                TypeSourceInfo *Operand,

                                SourceLocation RParenLoc) {

  // C++ [expr.typeid]p4:

  //   The top-level cv-qualifiers of the lvalue expression or the type-id

  //   that is the operand of typeid are always ignored.

  //   If the type of the type-id is a class type or a reference to a class

  //   type, the class shall be completely-defined.

  Qualifiers Quals;

  QualType T

    = Context.getUnqualifiedArrayType(Operand->getType().getNonReferenceType(),

                                      Quals);

  if (T->getAs<RecordType>() &&

      
RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid)251
)

    return ExprError();

  if (T->isVariablyModifiedType())

    return ExprError(Diag(TypeidLoc, diag::err_variably_modified_typeid) << T);

  if (CheckQualifiedFunctionForTypeId(T, TypeidLoc))

    return ExprError();

  return new (Context) CXXTypeidExpr(TypeInfoType.withConst(), Operand,

                                     SourceRange(TypeidLoc, RParenLoc));

}

/// Build a C++ typeid expression with an expression operand.

ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType,

                                SourceLocation TypeidLoc,

                                Expr *E,

                                SourceLocation RParenLoc) {

  bool WasEvaluated = false;

  if (E && !E->isTypeDependent()) {

    if (E->hasPlaceholderType()) {

      ExprResult result = CheckPlaceholderExpr(E);

      if (result.isInvalid()) 
return ExprError()0
;

      E = result.get();

    }

    QualType T = E->getType();

    if (const RecordType *RecordT = T->getAs<RecordType>()) {

      CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl());

      // C++ [expr.typeid]p3:

      //   [...] If the type of the expression is a class type, the class

      //   shall be completely-defined.

      if (RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))

        return ExprError();

      // C++ [expr.typeid]p3:

      //   When typeid is applied to an expression other than an glvalue of a

      //   polymorphic class type [...] [the] expression is an unevaluated

      //   operand. [...]

      if (RecordD->isPolymorphic() && 
E->isGLValue()122
) {

        if (isUnevaluatedContext()) {

          // The operand was processed in unevaluated context, switch the

          // context and recheck the subexpression.

          ExprResult Result = TransformToPotentiallyEvaluated(E);

          if (Result.isInvalid())

            return ExprError();

          E = Result.get();

        }

        // We require a vtable to query the type at run time.

        MarkVTableUsed(TypeidLoc, RecordD);

        WasEvaluated = true;

      }

    }

    ExprResult Result = CheckUnevaluatedOperand(E);

    if (Result.isInvalid())

      return ExprError();

    E = Result.get();

    // C++ [expr.typeid]p4:

    //   [...] If the type of the type-id is a reference to a possibly

    //   cv-qualified type, the result of the typeid expression refers to a

    //   std::type_info object representing the cv-unqualified referenced

    //   type.

    Qualifiers Quals;

    QualType UnqualT = Context.getUnqualifiedArrayType(T, Quals);

    if (!Context.hasSameType(T, UnqualT)) {

      T = UnqualT;

      E = ImpCastExprToType(E, UnqualT, CK_NoOp, E->getValueKind()).get();

    }

  }

  if (E->getType()->isVariablyModifiedType())

    return ExprError(Diag(TypeidLoc, diag::err_variably_modified_typeid)

                     << E->getType());

  else if (!inTemplateInstantiation() &&

           
E->HasSideEffects(Context, WasEvaluated)304
) {

    // The expression operand for typeid is in an unevaluated expression

    // context, so side effects could result in unintended consequences.

    Diag(E->getExprLoc(), WasEvaluated

                              ? 
diag::warn_side_effects_typeid42

                              : 
diag::warn_side_effects_unevaluated_context31
);

  }

  return new (Context) CXXTypeidExpr(TypeInfoType.withConst(), E,

                                     SourceRange(TypeidLoc, RParenLoc));

}

/// ActOnCXXTypeidOfType - Parse typeid( type-id ) or typeid (expression);

ExprResult

Sema::ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc,

                     bool isType, void *TyOrExpr, SourceLocation RParenLoc) {

  // typeid is not supported in OpenCL.

  if (getLangOpts().OpenCLCPlusPlus) {

    return ExprError(Diag(OpLoc, diag::err_openclcxx_not_supported)

                     << "typeid");

  }

  // Find the std::type_info type.

  if (!getStdNamespace())

    return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));

  if (!CXXTypeInfoDecl) {

    IdentifierInfo *TypeInfoII = &PP.getIdentifierTable().get("type_info");

    LookupResult R(*this, TypeInfoII, SourceLocation(), LookupTagName);

    LookupQualifiedName(R, getStdNamespace());

    CXXTypeInfoDecl = R.getAsSingle<RecordDecl>();

    // Microsoft's typeinfo doesn't have type_info in std but in the global

    // namespace if _HAS_EXCEPTIONS is defined to 0. See PR13153.

    if (!CXXTypeInfoDecl && 
LangOpts.MSVCCompat4
) {

      LookupQualifiedName(R, Context.getTranslationUnitDecl());

      CXXTypeInfoDecl = R.getAsSingle<RecordDecl>();

    }

    if (!CXXTypeInfoDecl)

      return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));

  }

  if (!getLangOpts().RTTI) {

    return ExprError(Diag(OpLoc, diag::err_no_typeid_with_fno_rtti));

  }

  QualType TypeInfoType = Context.getTypeDeclType(CXXTypeInfoDecl);

  if (isType) {

    // The operand is a type; handle it as such.

    TypeSourceInfo *TInfo = nullptr;

    QualType T = GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr),

                                   &TInfo);

    if (T.isNull())

      return ExprError();

    if (!TInfo)

      TInfo = Context.getTrivialTypeSourceInfo(T, OpLoc);

    return BuildCXXTypeId(TypeInfoType, OpLoc, TInfo, RParenLoc);

  }

  // The operand is an expression.

  ExprResult Result =

      BuildCXXTypeId(TypeInfoType, OpLoc, (Expr *)TyOrExpr, RParenLoc);

  if (!getLangOpts().RTTIData && 
!Result.isInvalid()15
)

    if (auto *CTE = dyn_cast<CXXTypeidExpr>(Result.get()))

      if (CTE->isPotentiallyEvaluated() && 
!CTE->isMostDerived(Context)11
)

        Diag(OpLoc, diag::warn_no_typeid_with_rtti_disabled)

            << (getDiagnostics().getDiagnosticOptions().getFormat() ==

                DiagnosticOptions::MSVC);

  return Result;

}

/// Grabs __declspec(uuid()) off a type, or returns 0 if we cannot resolve to

/// a single GUID.

static void

getUuidAttrOfType(Sema &SemaRef, QualType QT,

                  llvm::SmallSetVector<const UuidAttr *, 1> &UuidAttrs) {

  // Optionally remove one level of pointer, reference or array indirection.

  const Type *Ty = QT.getTypePtr();

  if (QT->isPointerType() || 
QT->isReferenceType()169
)

    Ty = QT->getPointeeType().getTypePtr();

  else if (QT->isArrayType())

    Ty = Ty->getBaseElementTypeUnsafe();

  const auto *TD = Ty->getAsTagDecl();

  if (!TD)

    return;

  if (const auto *Uuid = TD->getMostRecentDecl()->getAttr<UuidAttr>()) {

    UuidAttrs.insert(Uuid);

    return;

  }

  // __uuidof can grab UUIDs from template arguments.

  if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(TD)) {

    const TemplateArgumentList &TAL = CTSD->getTemplateArgs();

    for (const TemplateArgument &TA : TAL.asArray()) {

      const UuidAttr *UuidForTA = nullptr;

      if (TA.getKind() == TemplateArgument::Type)

        getUuidAttrOfType(SemaRef, TA.getAsType(), UuidAttrs);

      else if (TA.getKind() == TemplateArgument::Declaration)

        getUuidAttrOfType(SemaRef, TA.getAsDecl()->getType(), UuidAttrs);

      if (UuidForTA)

        UuidAttrs.insert(UuidForTA);

    }

  }

}

/// Build a Microsoft __uuidof expression with a type operand.

ExprResult Sema::BuildCXXUuidof(QualType Type,

                                SourceLocation TypeidLoc,

                                TypeSourceInfo *Operand,

                                SourceLocation RParenLoc) {

  MSGuidDecl *Guid = nullptr;

  if (!Operand->getType()->isDependentType()) {

    llvm::SmallSetVector<const UuidAttr *, 1> UuidAttrs;

    getUuidAttrOfType(*this, Operand->getType(), UuidAttrs);

    if (UuidAttrs.empty())

      return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid));

    if (UuidAttrs.size() > 1)

      return ExprError(Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));

    Guid = UuidAttrs.back()->getGuidDecl();

  }

  return new (Context)

      CXXUuidofExpr(Type, Operand, Guid, SourceRange(TypeidLoc, RParenLoc));

}

/// Build a Microsoft __uuidof expression with an expression operand.

ExprResult Sema::BuildCXXUuidof(QualType Type, SourceLocation TypeidLoc,

                                Expr *E, SourceLocation RParenLoc) {

  MSGuidDecl *Guid = nullptr;

  if (!E->getType()->isDependentType()) {

    if (E->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {

      // A null pointer results in {00000000-0000-0000-0000-000000000000}.

      Guid = Context.getMSGuidDecl(MSGuidDecl::Parts{});

    } else {

      llvm::SmallSetVector<const UuidAttr *, 1> UuidAttrs;

      getUuidAttrOfType(*this, E->getType(), UuidAttrs);

      if (UuidAttrs.empty())

        return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid));

      if (UuidAttrs.size() > 1)

        return ExprError(Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));

      Guid = UuidAttrs.back()->getGuidDecl();

    }

  }

  return new (Context)

      CXXUuidofExpr(Type, E, Guid, SourceRange(TypeidLoc, RParenLoc));

}

/// ActOnCXXUuidof - Parse __uuidof( type-id ) or __uuidof (expression);

ExprResult

Sema::ActOnCXXUuidof(SourceLocation OpLoc, SourceLocation LParenLoc,

                     bool isType, void *TyOrExpr, SourceLocation RParenLoc) {

  QualType GuidType = Context.getMSGuidType();

  GuidType.addConst();

  if (isType) {

    // The operand is a type; handle it as such.

    TypeSourceInfo *TInfo = nullptr;

    QualType T = GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr),

                                   &TInfo);

    if (T.isNull())

      return ExprError();

    if (!TInfo)

      TInfo = Context.getTrivialTypeSourceInfo(T, OpLoc);

    return BuildCXXUuidof(GuidType, OpLoc, TInfo, RParenLoc);

  }

  // The operand is an expression.

  return BuildCXXUuidof(GuidType, OpLoc, (Expr*)TyOrExpr, RParenLoc);

}

/// ActOnCXXBoolLiteral - Parse {true,false} literals.

ExprResult

Sema::ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind) {

  assert((Kind == tok::kw_true || Kind == tok::kw_false) &&

         "Unknown C++ Boolean value!");

  return new (Context)

      CXXBoolLiteralExpr(Kind == tok::kw_true, Context.BoolTy, OpLoc);

}

/// ActOnCXXNullPtrLiteral - Parse 'nullptr'.

ExprResult

Sema::ActOnCXXNullPtrLiteral(SourceLocation Loc) {

  return new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc);

}

/// ActOnCXXThrow - Parse throw expressions.

ExprResult

Sema::ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *Ex) {

  bool IsThrownVarInScope = false;

  if (Ex) {

    // C++0x [class.copymove]p31:

    //   When certain criteria are met, an implementation is allowed to omit the

    //   copy/move construction of a class object [...]

    //

    //     - in a throw-expression, when the operand is the name of a

    //       non-volatile automatic object (other than a function or catch-

    //       clause parameter) whose scope does not extend beyond the end of the

    //       innermost enclosing try-block (if there is one), the copy/move

    //       operation from the operand to the exception object (15.1) can be

    //       omitted by constructing the automatic object directly into the

    //       exception object

    if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Ex->IgnoreParens()))

      if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {

        if (Var->hasLocalStorage() && 
!Var->getType().isVolatileQualified()555
) {

          for( ; S; 
S = S->getParent()65
) {

            if (S->isDeclScope(Var)) {

              IsThrownVarInScope = true;

              break;

            }

            if (S->getFlags() &

                (Scope::FnScope | Scope::ClassScope | Scope::BlockScope |

                 Scope::FunctionPrototypeScope | Scope::ObjCMethodScope |

                 Scope::TryScope))

              break;

          }

        }

      }

  }

  return BuildCXXThrow(OpLoc, Ex, IsThrownVarInScope);

}

ExprResult Sema::BuildCXXThrow(SourceLocation OpLoc, Expr *Ex,

                               bool IsThrownVarInScope) {

  // Don't report an error if 'throw' is used in system headers.

  if (!getLangOpts().CXXExceptions &&

      
!getSourceManager().isInSystemHeader(OpLoc)13
 && 
!getLangOpts().CUDA13
) {

    // Delay error emission for the OpenMP device code.

    targetDiag(OpLoc, diag::err_exceptions_disabled) << "throw";

  }

  // Exceptions aren't allowed in CUDA device code.

  if (getLangOpts().CUDA)

    CUDADiagIfDeviceCode(OpLoc, diag::err_cuda_device_exceptions)

        << "throw" << CurrentCUDATarget();

  if (getCurScope() && getCurScope()->isOpenMPSimdDirectiveScope())

    Diag(OpLoc, diag::err_omp_simd_region_cannot_use_stmt) << "throw";

  if (Ex && 
!Ex->isTypeDependent()7.88k
) {

    // Initialize the exception result.  This implicitly weeds out

    // abstract types or types with inaccessible copy constructors.

    // C++0x [class.copymove]p31:

    //   When certain criteria are met, an implementation is allowed to omit the

    //   copy/move construction of a class object [...]

    //

    //     - in a throw-expression, when the operand is the name of a

    //       non-volatile automatic object (other than a function or

    //       catch-clause

    //       parameter) whose scope does not extend beyond the end of the

    //       innermost enclosing try-block (if there is one), the copy/move

    //       operation from the operand to the exception object (15.1) can be

    //       omitted by constructing the automatic object directly into the

    //       exception object

    NamedReturnInfo NRInfo =

        IsThrownVarInScope ? 
getNamedReturnInfo(Ex)97
 : 
NamedReturnInfo()6.40k
;

    QualType ExceptionObjectTy = Context.getExceptionObjectType(Ex->getType());

    if (CheckCXXThrowOperand(OpLoc, ExceptionObjectTy, Ex))

      return ExprError();

    InitializedEntity Entity =

        InitializedEntity::InitializeException(OpLoc, ExceptionObjectTy);

    ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRInfo, Ex);

    if (Res.isInvalid())

      return ExprError();

    Ex = Res.get();

  }

  // PPC MMA non-pointer types are not allowed as throw expr types.

  if (Ex && 
Context.getTargetInfo().getTriple().isPPC64()7.82k
)

    CheckPPCMMAType(Ex->getType(), Ex->getBeginLoc());

  return new (Context)

      CXXThrowExpr(Ex, Context.VoidTy, OpLoc, IsThrownVarInScope);

}

static void

collectPublicBases(CXXRecordDecl *RD,

                   llvm::DenseMap<CXXRecordDecl *, unsigned> &SubobjectsSeen,

                   llvm::SmallPtrSetImpl<CXXRecordDecl *> &VBases,

                   llvm::SetVector<CXXRecordDecl *> &PublicSubobjectsSeen,

                   bool ParentIsPublic) {

  for (const CXXBaseSpecifier &BS : RD->bases()) {

    CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();

    bool NewSubobject;

    // Virtual bases constitute the same subobject.  Non-virtual bases are

    // always distinct subobjects.

    if (BS.isVirtual())

      NewSubobject = VBases.insert(BaseDecl).second;

    else

      NewSubobject = true;

    if (NewSubobject)

      ++SubobjectsSeen[BaseDecl];

    // Only add subobjects which have public access throughout the entire chain.

    bool PublicPath = ParentIsPublic && BS.getAccessSpecifier() == AS_public;

    if (PublicPath)

      PublicSubobjectsSeen.insert(BaseDecl);

    // Recurse on to each base subobject.

    collectPublicBases(BaseDecl, SubobjectsSeen, VBases, PublicSubobjectsSeen,

                       PublicPath);

  }

}

static void getUnambiguousPublicSubobjects(

    CXXRecordDecl *RD, llvm::SmallVectorImpl<CXXRecordDecl *> &Objects) {

  llvm::DenseMap<CXXRecordDecl *, unsigned> SubobjectsSeen;

  llvm::SmallSet<CXXRecordDecl *, 2> VBases;

  llvm::SetVector<CXXRecordDecl *> PublicSubobjectsSeen;

  SubobjectsSeen[RD] = 1;

  PublicSubobjectsSeen.insert(RD);

  collectPublicBases(RD, SubobjectsSeen, VBases, PublicSubobjectsSeen,

                     /*ParentIsPublic=*/true);

  for (CXXRecordDecl *PublicSubobject : PublicSubobjectsSeen) {

    // Skip ambiguous objects.

    if (SubobjectsSeen[PublicSubobject] > 1)

      continue;

    Objects.push_back(PublicSubobject);

  }

}

/// CheckCXXThrowOperand - Validate the operand of a throw.

bool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc,

                                QualType ExceptionObjectTy, Expr *E) {

  //   If the type of the exception would be an incomplete type or a pointer

  //   to an incomplete type other than (cv) void the program is ill-formed.

  QualType Ty = ExceptionObjectTy;

  bool isPointer = false;

  if (const PointerType* Ptr = Ty->getAs<PointerType>()) {

    Ty = Ptr->getPointeeType();

    isPointer = true;

  }

  if (!isPointer || 
!Ty->isVoidType()144
) {

    if (RequireCompleteType(ThrowLoc, Ty,

                            isPointer ? 
diag::err_throw_incomplete_ptr136

                                      : 
diag::err_throw_incomplete6.35k
,

                            E->getSourceRange()))

      return true;

    if (!isPointer && 
Ty->isSizelessType()6.33k
) {

      Diag(ThrowLoc, diag::err_throw_sizeless) << Ty << E->getSourceRange();

      return true;

    }

    if (RequireNonAbstractType(ThrowLoc, ExceptionObjectTy,

                               diag::err_throw_abstract_type, E))

      return true;

  }

  // If the exception has class type, we need additional handling.

  CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();

  if (!RD)

    return false;

  // If we are throwing a polymorphic class type or pointer thereof,

  // exception handling will make use of the vtable.

  MarkVTableUsed(ThrowLoc, RD);

  // If a pointer is thrown, the referenced object will not be destroyed.

  if (isPointer)

    return false;

  // If the class has a destructor, we must be able to call it.

  if (!RD->hasIrrelevantDestructor()) {

    if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {

      MarkFunctionReferenced(E->getExprLoc(), Destructor);

      CheckDestructorAccess(E->getExprLoc(), Destructor,

                            PDiag(diag::err_access_dtor_exception) << Ty);

      if (DiagnoseUseOfDecl(Destructor, E->getExprLoc()))

        return true;

    }

  }

  // The MSVC ABI creates a list of all types which can catch the exception

  // object.  This list also references the appropriate copy constructor to call

  // if the object is caught by value and has a non-trivial copy constructor.

  if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {

    // We are only interested in the public, unambiguous bases contained within

    // the exception object.  Bases which are ambiguous or otherwise

    // inaccessible are not catchable types.

    llvm::SmallVector<CXXRecordDecl *, 2> UnambiguousPublicSubobjects;

    getUnambiguousPublicSubobjects(RD, UnambiguousPublicSubobjects);

    for (CXXRecordDecl *Subobject : UnambiguousPublicSubobjects) {

      // Attempt to lookup the copy constructor.  Various pieces of machinery

      // will spring into action, like template instantiation, which means this

      // cannot be a simple walk of the class's decls.  Instead, we must perform

      // lookup and overload resolution.

      CXXConstructorDecl *CD = LookupCopyingConstructor(Subobject, 0);

      if (!CD || CD->isDeleted())

        continue;

      // Mark the constructor referenced as it is used by this throw expression.

      MarkFunctionReferenced(E->getExprLoc(), CD);

      // Skip this copy constructor if it is trivial, we don't need to record it

      // in the catchable type data.