Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/ASTImporter_8cpp_source.html below:

clang: lib/AST/ASTImporter.cpp Source File

llvm::make_error;

;

;

;

llvm_unreachable(

);

;

llvm_unreachable(

);

(

*R :

->getFirstDecl()->

()) {

(R !=

->getFirstDecl())

Redecls.push_back(R);

Redecls.push_back(

->getFirstDecl());

std::reverse(Redecls.begin(), Redecls.end());

(

*FD = dyn_cast<FunctionDecl>(

))

getCanonicalForwardRedeclChain<FunctionDecl>(FD);

(

*VD = dyn_cast<VarDecl>(

))

getCanonicalForwardRedeclChain<VarDecl>(VD);

(

*TD = dyn_cast<TagDecl>(

))

getCanonicalForwardRedeclChain<TagDecl>(TD);

llvm_unreachable(

);

IgnoreChildErrors;

: FromDC(FromDC), IgnoreChildErrors(!

<

>(FromDC)) {}

IgnoreChildErrors(!

<

>(FromD)) {}

(ChildErr && !IgnoreChildErrors)

ResultErr = joinErrors(std::move(ResultErr), std::move(ChildErr));

consumeError(std::move(ChildErr));

(!IgnoreChildErrors || !FromDC)

<ASTNodeImporter, ExpectedDecl>,

<ASTNodeImporter, ExpectedStmt> {

<

ImportT>

[[nodiscard]] Error importInto(ImportT &To,

ImportT &From) {

<

ImportT>

[[nodiscard]] Error importInto(ImportT *&To, ImportT *From) {

ToOrErr = Importer.

(From);

To = cast_or_null<ImportT>(*ToOrErr);

ToOrErr.takeError();

<

T>

(

*From)

ToOrErr = Importer.

(From);

ToOrErr.takeError();

cast_or_null<T>(*ToOrErr);

<

T>

(

*From) {

(

*

(From));

<

T>

Importer.

(From);

<

T>

(*From);

<

ToDeclT>

CallOverloadedCreateFun {

<

... Args>

(

)

()(Args &&... args) {

ToDeclT::Create(std::forward<Args>(args)...);

<

ToDeclT,

FromDeclT,

... Args>

[[nodiscard]]

GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,

CallOverloadedCreateFun<ToDeclT> OC;

GetImportedOrCreateSpecialDecl(ToD, OC, FromD,

std::forward<Args>(args)...);

<

NewDeclT,

ToDeclT,

FromDeclT,

[[nodiscard]]

GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,

CallOverloadedCreateFun<NewDeclT> OC;

GetImportedOrCreateSpecialDecl(ToD, OC, FromD,

std::forward<Args>(args)...);

<

ToDeclT,

CreateFunT,

FromDeclT,

GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,

FromDeclT *FromD, Args &&...args) {

ToD = CreateFun(std::forward<Args>(args)...);

Importer.SharedState->markAsNewDecl(ToD);

InitializeImportedDecl(FromD, ToD);

InitializeImportedDecl(

*FromD,

*ToD) {

(FromD->isImplicit())

(

->doesThisDeclarationHaveABody() &&

addDeclToContexts(

*FromD,

*ToD) {

(!FromD->getDescribedTemplate() &&

*FromLexicalDC = FromD->getLexicalDeclContext();

Visible =

;

(

*FromNamed = dyn_cast<NamedDecl>(FromD)) {

*ToNamed = cast<NamedDecl>(ToD);

FromDC->

(FromNamed->getDeclName());

(llvm::is_contained(FromLookup, FromNamed))

updateLookupTableForTemplateParameters(

<

TemplateParmDeclT>

Error importTemplateParameterDefaultArgument(

TemplateParmDeclT *

,

TemplateParmDeclT *ToD) {

(

->hasDefaultArgument()) {

(

->defaultArgumentWasInherited()) {

(

->getDefaultArgStorage().getInheritedFrom());

(!ToInheritedFromOrErr)

ToInheritedFromOrErr.takeError();

TemplateParmDeclT *ToInheritedFrom = *ToInheritedFromOrErr;

(!ToInheritedFrom->hasDefaultArgument()) {

(

->getDefaultArgStorage()

->getDefaultArgument());

(!ToInheritedDefaultArgOrErr)

ToInheritedDefaultArgOrErr.takeError();

ToInheritedFrom->setDefaultArgument(Importer.

(),

*ToInheritedDefaultArgOrErr);

ToD->setInheritedDefaultArgument(ToD->getASTContext(),

(

->getDefaultArgument());

(!ToDefaultArgOrErr)

ToDefaultArgOrErr.takeError();

(!ToD->hasDefaultArgument())

Error::success();

<

InContainerTy>

<

InContainerTy>

std::tuple<FunctionTemplateDecl *, TemplateArgsTy>;

<

DeclTy>

<

T>

IgnoreTemplateParmDepth =

);

Err = MaybeVal.takeError();

<

IIter,

OIter>

ItemT = std::remove_reference_t<

(*Obegin)>;

(; Ibegin != Iend; ++Ibegin, ++Obegin) {

ToOrErr.takeError();

Error::success();

<

InContainerTy,

OutContainerTy>

InContainerTy &InContainer, OutContainerTy &OutContainer) {

InContainer.begin(), InContainer.end(), OutContainer.begin());

<

InContainerTy,

OIter>

<

InContainerTy>

ToLAngleLocOrErr =

(FromLAngleLoc);

(!ToLAngleLocOrErr)

ToLAngleLocOrErr.takeError();

ToRAngleLocOrErr =

(FromRAngleLoc);

(!ToRAngleLocOrErr)

ToRAngleLocOrErr.takeError();

Error::success();

Error ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(

ImportTemplateArgumentListInfo(

From.LAngleLoc, From.RAngleLoc, From.arguments(),

);

(Error Err = importInto(std::get<0>(

), FTSInfo->getTemplate()))

std::move(Err);

std::move(Err);

std::move(Err);

(!ToRequiresClause)

ToRequiresClause.takeError();

(!ToTemplateLocOrErr)

ToTemplateLocOrErr.takeError();

ToLAngleLocOrErr =

(From->

());

(!ToLAngleLocOrErr)

ToLAngleLocOrErr.takeError();

ToRAngleLocOrErr =

(From->

());

(!ToRAngleLocOrErr)

ToRAngleLocOrErr.takeError();

ToTypeOrErr.takeError();

ToTypeOrErr.takeError();

ToOrErr.takeError();

ToTypeOrErr.takeError();

(dyn_cast<ValueDecl>((*ToOrErr)->getCanonicalDecl()),

ToTypeOrErr.takeError();

ToTypeOrErr.takeError();

ToValueOrErr.takeError();

(!ToTemplateOrErr)

ToTemplateOrErr.takeError();

(!ToTemplateOrErr)

ToTemplateOrErr.takeError();

ToExpr.takeError();

std::move(Err);

llvm_unreachable(

);

ArgOrErr.takeError();

.takeError();

TSIOrErr.takeError();

ToTemplateQualifierLocOrErr =

(!ToTemplateQualifierLocOrErr)

ToTemplateQualifierLocOrErr.takeError();

(!ToTemplateNameLocOrErr)

ToTemplateNameLocOrErr.takeError();

ToTemplateEllipsisLocOrErr =

(!ToTemplateEllipsisLocOrErr)

ToTemplateEllipsisLocOrErr.takeError();

Importer.

(), *ToTemplateQualifierLocOrErr,

*ToTemplateNameLocOrErr, *ToTemplateEllipsisLocOrErr);

NumDecls = DG.

() - DG.

();

ToDecls.reserve(NumDecls);

(

*FromD : DG) {

(

ToDOrErr =

(FromD))

ToDecls.push_back(*ToDOrErr);

ToDOrErr.takeError();

(

.isFieldDesignator()) {

ToDotLocOrErr.takeError();

(!ToFieldLocOrErr)

ToFieldLocOrErr.takeError();

ToFieldName, *ToDotLocOrErr, *ToFieldLocOrErr);

ToLBracketLocOrErr =

(

.getLBracketLoc());

(!ToLBracketLocOrErr)

ToLBracketLocOrErr.takeError();

ToRBracketLocOrErr =

(

.getRBracketLoc());

(!ToRBracketLocOrErr)

ToRBracketLocOrErr.takeError();

(

.isArrayDesignator())

*ToLBracketLocOrErr,

*ToRBracketLocOrErr);

ToEllipsisLocOrErr =

(

.getEllipsisLoc());

(!ToEllipsisLocOrErr)

ToEllipsisLocOrErr.takeError();

assert(

.isArrayRangeDesignator());

.getArrayIndex(), *ToLBracketLocOrErr, *ToEllipsisLocOrErr,

*ToRBracketLocOrErr);

Error Err = Error::success();

ToConceptNameLoc =

std::move(Err);

(ASTTemplateArgs)

std::move(Err);

VarOrErr.takeError();

LocationOrErr =

(From.

());

LocationOrErr.takeError();

(Error Err = importInto(EllipsisLoc, From.

()))

std::move(Err);

<

T>

(

->getLinkageInternal() != From->getLinkageInternal())

(From->hasExternalFormalLinkage())

->hasExternalFormalLinkage();

(From->isInAnonymousNamespace())

->isInAnonymousNamespace();

!

->isInAnonymousNamespace() &&

!

->hasExternalFormalLinkage();

;

UnderlyingTypeOrErr =

(

->getValueType());

(!UnderlyingTypeOrErr)

UnderlyingTypeOrErr.takeError();

(

->getKind()) {

BuiltinType::Char_U:

BuiltinType::Char_S:

BuiltinType::WChar_S:

BuiltinType::WChar_U:

llvm_unreachable(

);

ToOriginalTypeOrErr =

(

->getOriginalType());

(!ToOriginalTypeOrErr)

ToOriginalTypeOrErr.takeError();

ToElementTypeOrErr =

(

->getElementType());

(!ToElementTypeOrErr)

ToElementTypeOrErr.takeError();

(!ToPointeeTypeOrErr)

ToPointeeTypeOrErr.takeError();

(!ToPointeeTypeOrErr)

ToPointeeTypeOrErr.takeError();

ToPointeeTypeOrErr =

(

->getPointeeTypeAsWritten());

(!ToPointeeTypeOrErr)

ToPointeeTypeOrErr.takeError();

ToPointeeTypeOrErr =

(

->getPointeeTypeAsWritten());

(!ToPointeeTypeOrErr)

ToPointeeTypeOrErr.takeError();

(!ToPointeeTypeOrErr)

ToPointeeTypeOrErr.takeError();

(!ClassTypeOrErr)

ClassTypeOrErr.takeError();

Err = Error::success();

std::move(Err);

ToElementType,

->getSize(), ToSizeExpr,

->getSizeModifier(),

->getIndexTypeCVRQualifiers());

ToArrayTypeOrErr = VisitConstantArrayType(

);

(!ToArrayTypeOrErr)

ToArrayTypeOrErr.takeError();

ToElementTypeOrErr =

(

->getElementType());

(!ToElementTypeOrErr)

ToElementTypeOrErr.takeError();

->getSizeModifier(),

->getIndexTypeCVRQualifiers());

Err = Error::success();

std::move(Err);

ToElementType, ToSizeExpr,

->getSizeModifier(),

->getIndexTypeCVRQualifiers(), ToBracketsRange);

ASTNodeImporter::VisitDependentSizedArrayType(

Err = Error::success();

std::move(Err);

ToElementType, ToSizeExpr,

->getSizeModifier(),

->getIndexTypeCVRQualifiers(), ToBracketsRange);

ASTNodeImporter::VisitDependentSizedExtVectorType(

Err = Error::success();

std::move(Err);

ToElementType, ToSizeExpr, ToAttrLoc);

ToElementTypeOrErr =

(

->getElementType());

(!ToElementTypeOrErr)

ToElementTypeOrErr.takeError();

->getNumElements(),

->getVectorKind());

ToElementTypeOrErr =

(

->getElementType());

(!ToElementTypeOrErr)

ToElementTypeOrErr.takeError();

->getNumElements());

(!ToReturnTypeOrErr)

ToReturnTypeOrErr.takeError();

(!ToReturnTypeOrErr)

ToReturnTypeOrErr.takeError();

TyOrErr.takeError();

ArgTypes.push_back(*TyOrErr);

TyOrErr.takeError();

ExceptionTypes.push_back(*TyOrErr);

Err = Error::success();

std::move(Err);

*ToReturnTypeOrErr, ArgTypes, ToEPI);

Err = Error::success();

ToPrevD =

(Err,

->getDecl()->getPreviousDecl());

std::move(Err);

ToD, cast_or_null<TypeDecl>(ToPrevD));

ToInnerTypeOrErr =

(

->getInnerType());

(!ToInnerTypeOrErr)

ToInnerTypeOrErr.takeError();

Pattern.takeError();

Index.takeError();

ToDeclOrErr.takeError();

(!ToUnderlyingTypeOrErr)

ToUnderlyingTypeOrErr.takeError();

ToExprOrErr =

(

->getUnderlyingExpr());

ToExprOrErr.takeError();

ToUnderlyingTypeOrErr =

(

->getUnmodifiedType());

(!ToUnderlyingTypeOrErr)

ToUnderlyingTypeOrErr.takeError();

FoundOrErr.takeError();

(!UnderlyingOrErr)

UnderlyingOrErr.takeError();

ToExprOrErr =

(

->getUnderlyingExpr());

ToExprOrErr.takeError();

ToUnderlyingTypeOrErr =

(

->getUnderlyingType());

(!ToUnderlyingTypeOrErr)

ToUnderlyingTypeOrErr.takeError();

*ToExprOrErr, *ToUnderlyingTypeOrErr);

(!ToBaseTypeOrErr)

ToBaseTypeOrErr.takeError();

ToUnderlyingTypeOrErr =

(

->getUnderlyingType());

(!ToUnderlyingTypeOrErr)

ToUnderlyingTypeOrErr.takeError();

*ToBaseTypeOrErr, *ToUnderlyingTypeOrErr,

->getUTTKind());

ToDeducedTypeOrErr =

(

->getDeducedType());

(!ToDeducedTypeOrErr)

ToDeducedTypeOrErr.takeError();

ToTypeConstraintConcept =

(

->getTypeConstraintConcept());

(!ToTypeConstraintConcept)

ToTypeConstraintConcept.takeError();

std::move(Err);

*ToDeducedTypeOrErr,

->getKeyword(),

,

, cast_or_null<ConceptDecl>(*ToTypeConstraintConcept),

ASTNodeImporter::VisitDeducedTemplateSpecializationType(

(!ToTemplateNameOrErr)

ToTemplateNameOrErr.takeError();

ToDeducedTypeOrErr =

(

->getDeducedType());

(!ToDeducedTypeOrErr)

ToDeducedTypeOrErr.takeError();

ASTNodeImporter::VisitInjectedClassNameType(

ToDeclOrErr.takeError();

*Ty = (*ToDeclOrErr)->getTypeForDecl();

assert(isa_and_nonnull<InjectedClassNameType>(Ty));

ToDeclOrErr.takeError();

ToDeclOrErr.takeError();

ToModifiedTypeOrErr =

(

->getModifiedType());

(!ToModifiedTypeOrErr)

ToModifiedTypeOrErr.takeError();

ToEquivalentTypeOrErr =

(

->getEquivalentType());

(!ToEquivalentTypeOrErr)

ToEquivalentTypeOrErr.takeError();

->getAttrKind(), *ToModifiedTypeOrErr, *ToEquivalentTypeOrErr,

(!ToWrappedTypeOrErr)

ToWrappedTypeOrErr.takeError();

Err = Error::success();

ToDeclOrErr.takeError();

CoupledDecls.emplace_back(*ToDeclOrErr, TI.isDeref());

*ToWrappedTypeOrErr, CountExpr,

->isCountInBytes(),

->isOrNull(),

(CoupledDecls.data(), CoupledDecls.size()));

ASTNodeImporter::VisitTemplateTypeParmType(

ToDeclOrErr.takeError();

->getDepth(),

->getIndex(),

->isParameterPack(), *ToDeclOrErr);

ASTNodeImporter::VisitSubstTemplateTypeParmType(

ReplacedOrErr.takeError();

ToReplacementTypeOrErr =

(

->getReplacementType());

(!ToReplacementTypeOrErr)

ToReplacementTypeOrErr.takeError();

*ToReplacementTypeOrErr, *ReplacedOrErr,

->getIndex(),

->getPackIndex(),

->getSubstitutionFlag());

ASTNodeImporter::VisitSubstTemplateTypeParmPackType(

ReplacedOrErr.takeError();

(!ToArgumentPack)

ToArgumentPack.takeError();

*ReplacedOrErr,

->getIndex(),

->getFinal(), *ToArgumentPack);

ASTNodeImporter::VisitTemplateSpecializationType(

ToTemplateOrErr =

(

->getTemplateName());

(!ToTemplateOrErr)

ToTemplateOrErr.takeError();

std::move(Err);

ToCanonType = *TyOrErr;

TyOrErr.takeError();

ToQualifierOrErr =

(

->getQualifier());

(!ToQualifierOrErr)

ToQualifierOrErr.takeError();

ToNamedTypeOrErr =

(

->getNamedType());

(!ToNamedTypeOrErr)

ToNamedTypeOrErr.takeError();

(!ToOwnedTagDeclOrErr)

ToOwnedTagDeclOrErr.takeError();

*ToOwnedTagDeclOrErr);

(!ToPatternOrErr)

ToPatternOrErr.takeError();

->getNumExpansions(),

ASTNodeImporter::VisitDependentTemplateSpecializationType(

ToQualifierOrErr =

(

->getQualifier());

(!ToQualifierOrErr)

ToQualifierOrErr.takeError();

ToPack.reserve(

->template_arguments().size());

std::move(Err);

->getKeyword(), *ToQualifierOrErr, ToName, ToPack);

ToQualifierOrErr =

(

->getQualifier());

(!ToQualifierOrErr)

ToQualifierOrErr.takeError();

TyOrErr.takeError();

ToDeclOrErr.takeError();

(!ToBaseTypeOrErr)

ToBaseTypeOrErr.takeError();

(

TypeArg :

->getTypeArgsAsWritten()) {

TypeArgs.push_back(*TyOrErr);

TyOrErr.takeError();

(

*

:

->quals()) {

Protocols.push_back(*ProtocolOrErr);

ProtocolOrErr.takeError();

->isKindOfTypeAsWritten());

(!ToPointeeTypeOrErr)

ToPointeeTypeOrErr.takeError();

ToUnderlyingTypeOrErr =

(

->getUnderlyingType());

(!ToUnderlyingTypeOrErr)

ToUnderlyingTypeOrErr.takeError();

Err = Error::success();

ToOriginalType = importChecked(Err,

->getOriginalType());

ToAdjustedType = importChecked(Err,

->getAdjustedType());

std::move(Err);

Importer.getToContext().getAdjustedType(ToOriginalType,

Importer.getToContext().getBitIntType(

->isUnsigned(),

clang::ASTNodeImporter::VisitBTFTagAttributedType(

Err = Error::success();

BTFTypeTagAttr *ToBTFAttr = importChecked(Err,

->getAttr());

ToWrappedType = importChecked(Err,

->getWrappedType());

std::move(Err);

Importer.getToContext().getBTFTagAttributedType(ToBTFAttr,

clang::ASTNodeImporter::VisitHLSLAttributedResourceType(

Err = Error::success();

ToWrappedType = importChecked(Err,

->getWrappedType());

ToContainedType = importChecked(Err,

->getContainedType());

std::move(Err);

Importer.getToContext().getHLSLAttributedResourceType(

ToWrappedType, ToContainedType, ToAttrs);

clang::ASTNodeImporter::VisitConstantMatrixType(

ToElementTypeOrErr =

(

->getElementType());

(!ToElementTypeOrErr)

ToElementTypeOrErr.takeError();

Importer.getToContext().getConstantMatrixType(

*ToElementTypeOrErr,

->getNumRows(),

->getNumColumns());

clang::ASTNodeImporter::VisitDependentAddressSpaceType(

Err = Error::success();

*ToAddrSpaceExpr = importChecked(Err,

->getAddrSpaceExpr());

std::move(Err);

Importer.getToContext().getDependentAddressSpaceType(

ToPointeeType, ToAddrSpaceExpr, ToAttrLoc);

clang::ASTNodeImporter::VisitDependentBitIntType(

ToNumBitsExprOrErr =

(

->getNumBitsExpr());

(!ToNumBitsExprOrErr)

ToNumBitsExprOrErr.takeError();

Importer.getToContext().getDependentBitIntType(

->isUnsigned(),

*ToNumBitsExprOrErr);

clang::ASTNodeImporter::VisitDependentSizedMatrixType(

Err = Error::success();

ToElementType = importChecked(Err,

->getElementType());

*ToRowExpr = importChecked(Err,

->getRowExpr());

*ToColumnExpr = importChecked(Err,

->getColumnExpr());

std::move(Err);

Importer.getToContext().getDependentSizedMatrixType(

ToElementType, ToRowExpr, ToColumnExpr, ToAttrLoc);

clang::ASTNodeImporter::VisitDependentVectorType(

Err = Error::success();

ToElementType = importChecked(Err,

->getElementType());

*ToSizeExpr = importChecked(Err,

->getSizeExpr());

std::move(Err);

Importer.getToContext().getDependentVectorType(

ToElementType, ToSizeExpr, ToAttrLoc,

->getVectorKind());

clang::ASTNodeImporter::VisitObjCTypeParamType(

ToDeclOrErr.takeError();

(!ToProtocolOrErr)

ToProtocolOrErr.takeError();

ToProtocols.push_back(*ToProtocolOrErr);

Importer.getToContext().getObjCTypeParamType(*ToDeclOrErr,

ToElementTypeOrErr =

(

->getElementType());

(!ToElementTypeOrErr)

ToElementTypeOrErr.takeError();

(

->isReadOnly())

(isa<RecordDecl>(

) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&

getLeafPointeeType = [](

*

) {

getLeafPointeeType(

->getType().getCanonicalType().getTypePtr());

*RT = dyn_cast<RecordType>(LeafT);

(RT && RT->getDecl() ==

) {

(Error Err = importInto(Name,

->getDeclName()))

Error::success();

(Error Err = importInto(Name,

->getDeclName()))

Error::success();

Error::success();

(Error Err = importInto(ToD, FromD))

(

*FromRecord = dyn_cast<RecordDecl>(FromD)) {

(

*ToRecord = cast<RecordDecl>(ToD)) {

(FromRecord->getDefinition() && FromRecord->isCompleteDefinition() &&

!ToRecord->getDefinition()) {

Error::success();

(

*FromEnum = dyn_cast<EnumDecl>(FromD)) {

(

*ToEnum = cast<EnumDecl>(ToD)) {

(FromEnum->getDefinition() && !ToEnum->getDefinition()) {

Error::success();

Error::success();

Error::success();

ToRangeOrErr.takeError();

Error::success();

LocOrErr.takeError();

Error::success();

ToTInfoOrErr.takeError();

Error::success();

llvm_unreachable(

);

ToDCOrErr.takeError();

MightNeedReordering = [](

*

) {

isa<FieldDecl>(

) || isa<IndirectFieldDecl>(

) || isa<FriendDecl>(

);

Error ChildErrors = Error::success();

(

*From : FromDC->

()) {

(!MightNeedReordering(From))

(!ImportedOrErr) {

ImportedOrErr.takeError());

*FieldFrom = dyn_cast_or_null<FieldDecl>(From);

*ImportedDecl = *ImportedOrErr;

*FieldTo = dyn_cast_or_null<FieldDecl>(ImportedDecl);

(FieldFrom && FieldTo) {

consumeError(std::move(ChildErrors));

ToDCOrErr.takeError();

(

*FromRD = dyn_cast<RecordDecl>(FromDC)) {

(

*

: FromRD->decls()) {

(!MightNeedReordering(

))

assert(

&&

);

assert(ToDC == ToD->getLexicalDeclContext() && ToDC->

(ToD));

(

*From : FromDC->

()) {

(MightNeedReordering(From))

ImportedOrErr.takeError());

(!FromRecordDecl || !ToRecordDecl) {

(RecordFrom && RecordTo) {

FromRecordDecl = RecordFrom->

();

ToRecordDecl = RecordTo->getDecl();

(FromRecordDecl && ToRecordDecl) {

Error::success();

ToDCOrErr.takeError();

(!ToLexicalDCOrErr)

ToLexicalDCOrErr.takeError();

ToLexicalDC = *ToLexicalDCOrErr;

Error::success();

);

(FromM->isImplicit()) {

ToMOrErr.takeError();

Error::success();

ToTypedefOrErr.takeError();

Error::success();

DefinitionCompleter = [To]() {

*FromCXXRD = cast<CXXRecordDecl>(From);

ToCaptures.reserve(FromCXXRD->capture_size());

(

&FromCapture : FromCXXRD->captures()) {

(

ToCaptureOrErr =

(FromCapture))

ToCaptures.push_back(*ToCaptureOrErr);

ToCaptureOrErr.takeError();

cast<CXXRecordDecl>(To)->setCaptures(Importer.

(),

DefinitionCompleter();

Error::success();

DefinitionCompleterScopeExit =

llvm::make_scope_exit(DefinitionCompleter);

*ToCXX = dyn_cast<CXXRecordDecl>(To);

*FromCXX = dyn_cast<CXXRecordDecl>(From);

(ToCXX && FromCXX && ToCXX->dataPtr() && FromCXX->dataPtr()) {

CXXRecordDecl::DefinitionData &ToData = ToCXX->data();

CXXRecordDecl::DefinitionData &FromData = FromCXX->data();

ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions());

(

&Base1 : FromCXX->bases()) {

TyOrErr.takeError();

(Base1.isPackExpansion()) {

(

LocOrErr =

(Base1.getEllipsisLoc()))

EllipsisLoc = *LocOrErr;

LocOrErr.takeError();

RangeOrErr =

(Base1.getSourceRange());

RangeOrErr.takeError();

TSIOrErr =

(Base1.getTypeSourceInfo());

TSIOrErr.takeError();

Base1.isBaseOfClass(),

Base1.getAccessSpecifierAsWritten(),

ToCXX->setBases(Bases.data(), Bases.size());

Error::success();

Error::success();

Error::success();

ToInitOrErr.takeError();

Error::success();

Error::success();

ToTypeOrErr.takeError();

(!ToPromotionTypeOrErr)

ToPromotionTypeOrErr.takeError();

Error::success();

(

&Arg : FromArgs) {

(

ToOrErr =

(Arg))

ToArgs.push_back(*ToOrErr);

ToOrErr.takeError();

Error::success();

(From);

<

InContainerTy>

(

&FromLoc : Container) {

(

ToLocOrErr =

(FromLoc))

ToLocOrErr.takeError();

Error::success();

IgnoreTemplateParmDepth) {

, Complain,

,

IgnoreTemplateParmDepth);

Ctx.IsEquivalent(From, To);

std::move(Err);

LocOrErr.takeError();

(GetImportedOrCreateDecl(ToD,

, Importer.

(), DC, *LocOrErr))

std::move(Err);

Name.getAsIdentifierInfo(),

->getType()))

Error Err = Error::success();

std::move(Err);

addDeclToContexts(

, ToD);

LocOrErr.takeError();

ColonLocOrErr =

(

->getColonLoc());

ColonLocOrErr.takeError();

DCOrErr.takeError();

DC, *LocOrErr, *ColonLocOrErr))

DCOrErr.takeError();

Error Err = Error::success();

std::move(Err);

(GetImportedOrCreateDecl(

ToD,

, Importer.

(), DC, ToLocation, ToAssertExpr, ToMessage,

ToRParenLoc,

->isFailed()))

std::move(Err);

(

*TU = dyn_cast<TranslationUnitDecl>(DC))

FoundDecls = Importer.findDeclsInToCtx(DC, Name);

(

*FoundDecl : FoundDecls) {

(

*FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) {

MergeWithNamespace = FoundNS;

ConflictingDecls.clear();

ConflictingDecls.push_back(FoundDecl);

(!ConflictingDecls.empty()) {

ConflictingDecls.size());

Name = NameOrErr.get();

NameOrErr.takeError();

BeginLocOrErr.takeError();

(!RBraceLocOrErr)

RBraceLocOrErr.takeError();

(GetImportedOrCreateDecl(ToNamespace,

, Importer.

(), DC,

->isInline(), *BeginLocOrErr,

,

Name.getAsIdentifierInfo(),

,

->isNested()))

(

*TU = dyn_cast<TranslationUnitDecl>(DC))

TU->setAnonymousNamespace(ToNamespace);

cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);

std::move(Err);

std::move(Err);

Error Err = Error::success();

ToNamespaceLoc =

(Err,

->getNamespaceLoc());

ToQualifierLoc =

(Err,

->getQualifierLoc());

ToTargetNameLoc =

(Err,

->getTargetNameLoc());

std::move(Err);

(GetImportedOrCreateDecl(

ToD,

, Importer.

(), DC, ToNamespaceLoc, ToAliasLoc,

ToIdentifier, ToQualifierLoc, ToTargetNameLoc, ToNamespace))

std::move(Err);

FoundDecls = Importer.findDeclsInToCtx(DC, Name);

(

*FoundDecl : FoundDecls) {

(

*FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {

FromUT =

->getUnderlyingType();

FoundUT = FoundTypedef->getUnderlyingType();

(FromR && FoundR &&

ConflictingDecls.push_back(FoundDecl);

(!ConflictingDecls.empty()) {

Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());

Name = NameOrErr.get();

NameOrErr.takeError();

Error Err = Error::success();

ToTypeSourceInfo =

(Err,

->getTypeSourceInfo());

std::move(Err);

(GetImportedOrCreateDecl<TypeAliasDecl>(

Name.getAsIdentifierInfo(), ToTypeSourceInfo))

}

(GetImportedOrCreateDecl<TypedefDecl>(

Name.getAsIdentifierInfo(), ToTypeSourceInfo))

std::move(Err);

Importer.AddToLookupTable(ToTypedef);

*FromAlias = IsAlias ? cast<TypeAliasDecl>(

) :

;

std::move(Err);

FoundDecls = Importer.findDeclsInToCtx(DC, Name);

(

*FoundDecl : FoundDecls) {

(

*FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl)) {

ConflictingDecls.push_back(FoundDecl);

(!ConflictingDecls.empty()) {

Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());

Name = NameOrErr.get();

NameOrErr.takeError();

Error Err = Error::success();

ToTemplateParameters =

(Err,

->getTemplateParameters());

ToTemplatedDecl =

(Err,

->getTemplatedDecl());

std::move(Err);

(GetImportedOrCreateDecl(ToAlias,

, Importer.

(), DC,

,

Name, ToTemplateParameters, ToTemplatedDecl))

ToTemplatedDecl->setDescribedAliasTemplate(ToAlias);

updateLookupTableForTemplateParameters(*ToTemplateParameters);

std::move(Err);

(

->isGnuLocal()) {

BeginLocOrErr.takeError();

(GetImportedOrCreateDecl(ToLabel,

, Importer.

(), DC,

,

Name.getAsIdentifierInfo(), *BeginLocOrErr))

(GetImportedOrCreateDecl(ToLabel,

, Importer.

(), DC,

,

Name.getAsIdentifierInfo()))

ToStmtOrErr.takeError();

ToLabel->

(*ToStmtOrErr);

std::move(Err);

(!SearchName &&

->getTypedefNameForAnonDecl()) {

(Error Err = importInto(

SearchName,

->getTypedefNameForAnonDecl()->getDeclName()))

std::move(Err);

Importer.findDeclsInToCtx(DC, SearchName);

(

*FoundDecl : FoundDecls) {

(

*Typedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {

(

*Tag = Typedef->getUnderlyingType()->getAs<

>())

FoundDecl = Tag->getDecl();

(

*FoundEnum = dyn_cast<EnumDecl>(FoundDecl)) {

(

->isThisDeclarationADefinition() && FoundDef)

ConflictingDecls.push_back(FoundDecl);

(SearchName && !ConflictingDecls.empty()) {

SearchName, DC, IDNS, ConflictingDecls.data(),

ConflictingDecls.size());

Name = NameOrErr.get();

NameOrErr.takeError();

Error Err = Error::success();

ToQualifierLoc =

(Err,

->getQualifierLoc());

std::move(Err);

(GetImportedOrCreateDecl(

, Name.getAsIdentifierInfo(), PrevDecl,

->isScoped(),

->isScopedUsingClassTag(),

->isFixed()))

addDeclToContexts(

, D2);

*FromInst =

->getInstantiatedFromMemberEnum();

D2->setInstantiationOfMemberEnum(*ToInstOrErr, SK);

ToInstOrErr.takeError();

(

POIOrErr =

(MemberInfo->getPointOfInstantiation()))

POIOrErr.takeError();

(

->isCompleteDefinition())

std::move(Err);

IsFriendTemplate =

;

(

*DCXX = dyn_cast<CXXRecordDecl>(

)) {

DCXX->getDescribedClassTemplate() &&

DCXX->getDescribedClassTemplate()->getFriendObjectKind() !=

*DC =

, *LexicalDC =

;

std::move(Err);

(!SearchName &&

->getTypedefNameForAnonDecl()) {

(Error Err = importInto(

SearchName,

->getTypedefNameForAnonDecl()->getDeclName()))

std::move(Err);

DependentFriend = IsFriendTemplate && IsDependentContext;

Importer.findDeclsInToCtx(DC, SearchName);

(!FoundDecls.empty()) {

(

->hasExternalLexicalStorage() && !

->isCompleteDefinition())

(

*FoundDecl : FoundDecls) {

(

*Typedef = dyn_cast<TypedefNameDecl>(

)) {

(

*Tag = Typedef->getUnderlyingType()->getAs<

>())

= Tag->getDecl();

(

*FoundRecord = dyn_cast<RecordDecl>(

)) {

(

->isThisDeclarationADefinition() && FoundDef) {

(

*DCXX = dyn_cast<CXXRecordDecl>(

)) {

*FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);

assert(FoundCXX &&

);

std::move(Err);

ConflictingDecls.push_back(FoundDecl);

(!ConflictingDecls.empty() && SearchName) {

SearchName, DC, IDNS, ConflictingDecls.data(),

ConflictingDecls.size());

Name = NameOrErr.get();

NameOrErr.takeError();

BeginLocOrErr.takeError();

(

*DCXX = dyn_cast<CXXRecordDecl>(

)) {

(DCXX->isLambda()) {

TInfoOrErr =

(DCXX->getLambdaTypeInfo());

TInfoOrErr.takeError();

(GetImportedOrCreateSpecialDecl(

DC, *TInfoOrErr,

, DCXX->getLambdaDependencyKind(),

DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))

CDeclOrErr.takeError();

}

(DCXX->isInjectedClassName()) {

DelayTypeCreation =

;

(GetImportedOrCreateDecl(

*BeginLocOrErr,

, Name.getAsIdentifierInfo(),

cast_or_null<CXXRecordDecl>(PrevDecl), DelayTypeCreation))

D2CXX, dyn_cast<CXXRecordDecl>(DC));

(GetImportedOrCreateDecl(D2CXX,

, Importer.

(),

->getTagKind(), DC, *BeginLocOrErr,

,

Name.getAsIdentifierInfo(),

cast_or_null<CXXRecordDecl>(PrevDecl)))

addDeclToContexts(

, D2);

DCXX->getDescribedClassTemplate()) {

(Error Err = importInto(ToDescribed, FromDescribed))

std::move(Err);

(!DCXX->isInjectedClassName() && !IsFriendTemplate) {

*FrontTy =

cast<CXXRecordDecl>(Redecls.front())->getTypeForDecl();

InjSpec = InjTy->getInjectedSpecializationType();

(

*R : Redecls) {

*RI = cast<CXXRecordDecl>(R);

(R != Redecls.front() ||

!isa<InjectedClassNameType>(RI->getTypeForDecl()))

RI->setTypeForDecl(

);

DCXX->getMemberSpecializationInfo()) {

MemberInfo->getTemplateSpecializationKind();

ToInstOrErr.takeError();

(MemberInfo->getPointOfInstantiation()))

POIOrErr.takeError();

(GetImportedOrCreateDecl(D2,

, Importer.

(),

->getTagKind(), DC, *BeginLocOrErr,

,

Name.getAsIdentifierInfo(), PrevDecl))

addDeclToContexts(

, D2);

(

BraceRangeOrErr =

(

->getBraceRange()))

BraceRangeOrErr.takeError();

(

QualifierLocOrErr =

(

->getQualifierLoc()))

QualifierLocOrErr.takeError();

(

->isAnonymousStructOrUnion())

(

->isCompleteDefinition())

std::move(Err);

std::move(Err);

FoundDecls = Importer.findDeclsInToCtx(DC, Name);

(

*FoundDecl : FoundDecls) {

(

*FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) {

ConflictingDecls.push_back(FoundDecl);

(!ConflictingDecls.empty()) {

Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());

Name = NameOrErr.get();

NameOrErr.takeError();

TypeOrErr.takeError();

InitOrErr.takeError();

(GetImportedOrCreateDecl(

Name.getAsIdentifierInfo(), *TypeOrErr, *InitOrErr,

->getInitVal()))

ToEnumerator;

ToEnumerator;

<

DeclTy>

= FromD->getNumTemplateParameterLists();

Error::success();

(

I = 0; I <

; ++I)

(FromD->getTemplateParameterList(I)))

ToTPLists[I] = *ToTPListOrErr;

ToTPListOrErr.takeError();

ToD->setTemplateParameterListsInfo(Importer.ToContext, ToTPLists);

Error::success();

Error::success();

Error::success();

ToFD->setInstantiationOfMemberFunction(*InstFDOrErr, TSK);

InstFDOrErr.takeError();

POIOrErr.takeError();

Error::success();

FunctionAndArgsOrErr =

(!FunctionAndArgsOrErr)

FunctionAndArgsOrErr.takeError();

Importer.

(), std::get<1>(*FunctionAndArgsOrErr));

*FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;

(FromTAArgsAsWritten)

*FromTAArgsAsWritten, ToTAInfo))

POIOrErr =

(FTSInfo->getPointOfInstantiation());

POIOrErr.takeError();

ToFD->setFunctionTemplateSpecialization(

std::get<0>(*FunctionAndArgsOrErr), ToTAList,

,

TSK, FromTAArgsAsWritten ? &ToTAInfo :

, *POIOrErr);

Error::success();

Candidates.

(*ToFTDOrErr);

ToFTDOrErr.takeError();

*FromTAArgsAsWritten = FromInfo->TemplateArgumentsAsWritten;

(FromTAArgsAsWritten)

FromTAArgsAsWritten ? &ToTAInfo :

);

Error::success();

llvm_unreachable(

);

FunctionAndArgsOrErr =

(!FunctionAndArgsOrErr)

FunctionAndArgsOrErr.takeError();

std::tie(Template, ToTemplArgs) = *FunctionAndArgsOrErr;

*InsertPos =

;

ToFD->

(*ToBodyOrErr);

ToBodyOrErr.takeError();

Error::success();

assert(DCi &&

);

ToProcess.push_back(S);

(!ToProcess.empty()) {

*CurrentS = ToProcess.pop_back_val();

(

*DeclRef = dyn_cast<DeclRefExpr>(CurrentS)) {

(

*

= DeclRef->getDecl())

}

(

*

=

dyn_cast_or_null<SubstNonTypeTemplateParmExpr>(CurrentS)) {

(

*

=

->getAssociatedDecl())

IsTypeDeclaredInsideVisitor

:

<IsTypeDeclaredInsideVisitor, std::optional<bool>> {

IsTypeDeclaredInsideVisitor(

*ParentDC)

: ParentDC(ParentDC) {}

(std::optional<bool> Res = Visit(

.getTypePtr()))

.getSingleStepDesugaredType(ParentDC->getParentASTContext());

(std::optional<bool> Res = Visit(DsT.

()))

DsT =

.getSingleStepDesugaredType(ParentDC->getParentASTContext());

std::optional<bool> VisitTagType(

*

) {

(

*Spec = dyn_cast<ClassTemplateSpecializationDecl>(

->getDecl()))

(

&Arg : Spec->getTemplateArgs().asArray())

(checkTemplateArgument(Arg))

std::optional<bool> VisitPointerType(

*

) {

std::optional<bool> VisitReferenceType(

*

) {

CheckType(

->getPointeeTypeAsWritten());

std::optional<bool> VisitTypedefType(

*

) {

std::optional<bool> VisitUsingType(

*

) {

(

->getFoundDecl() &&

(

&Arg :

->template_arguments())

(checkTemplateArgument(Arg))

CheckType(

->getBaseType());

CheckType(

->getElementType());

);

llvm_unreachable(

llvm_unreachable(

(checkTemplateArgument(PackArg))

llvm_unreachable(

);

assert(FromFPT &&

);

IsCXX11Lambda = [&]() {

(Importer.FromContext.

().CPlusPlus14)

RetT = FromFPT->getReturnType();

(isa<AutoType>(RetT.

()) || IsCXX11Lambda()) {

IsTypeDeclaredInsideVisitor Visitor(Def ? Def :

);

Visitor.CheckType(RetT);

RedeclIt = Redecls.begin();

(; RedeclIt != Redecls.end() && *RedeclIt !=

; ++RedeclIt) {

ToRedeclOrErr.takeError();

assert(*RedeclIt ==

);

std::move(Err);

(

->getTemplatedKind() ==

(!FoundFunctionOrErr)

FoundFunctionOrErr.takeError();

(

*FoundFunction = *FoundFunctionOrErr) {

(

*Def = FindAndMapDefinition(

, FoundFunction))

FoundByLookup = FoundFunction;

FoundDecls = Importer.findDeclsInToCtx(DC, Name);

(

*FoundDecl : FoundDecls) {

(

*FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {

(

*Def = FindAndMapDefinition(

, FoundFunction))

FoundByLookup = FoundFunction;

Importer.

(

, diag::warn_odr_function_type_inconsistent)

<< Name <<

->getType() << FoundFunction->getType();

Importer.

(FoundFunction->getLocation(), diag::note_odr_value_here)

<< FoundFunction->getType();

ConflictingDecls.push_back(FoundDecl);

(!ConflictingDecls.empty()) {

Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());

Name = NameOrErr.get();

NameOrErr.takeError();

(FoundByLookup) {

(isa<CXXMethodDecl>(FoundByLookup)) {

(!

->doesThisDeclarationHaveABody()) {

->getDescribedFunctionTemplate()) {

);

std::move(Err);

UsedDifferentProtoType =

;

FromReturnTy = FromFPT->getReturnType();

UsedDifferentProtoType =

;

FromEPI = DefaultEPI;

UsedDifferentProtoType =

;

FromReturnTy, FromFPT->getParamTypes(), FromEPI);

Error Err = Error::success();

ToInnerLocStart =

(Err,

->getInnerLocStart());

ToQualifierLoc =

(Err,

->getQualifierLoc());

TrailingRequiresClause =

std::move(Err);

(

*

:

->parameters()) {

Parameters.push_back(*ToPOrErr);

ToPOrErr.takeError();

(

*FromConstructor = dyn_cast<CXXConstructorDecl>(

)) {

importExplicitSpecifier(Err, FromConstructor->getExplicitSpecifier());

std::move(Err);

(FromConstructor->isInheritingConstructor()) {

(FromConstructor->getInheritedConstructor());

(!ImportedInheritedCtor)

ImportedInheritedCtor.takeError();

ToInheritedConstructor = *ImportedInheritedCtor;

(GetImportedOrCreateDecl<CXXConstructorDecl>(

ToFunction,

, Importer.

(), cast<CXXRecordDecl>(DC),

ToInnerLocStart, NameInfo,

, TInfo, ESpec,

->UsesFPIntrin(),

->isInlineSpecified(),

->

(),

->getConstexprKind(),

ToInheritedConstructor, TrailingRequiresClause))

Error Err = Error::success();

Err,

*

(FromDtor->getOperatorDelete()));

ToThisArg =

(Err, FromDtor->getOperatorDeleteThisArg());

std::move(Err);

(GetImportedOrCreateDecl<CXXDestructorDecl>(

ToFunction,

, Importer.

(), cast<CXXRecordDecl>(DC),

ToInnerLocStart, NameInfo,

, TInfo,

->UsesFPIntrin(),

->isInlineSpecified(),

->

(),

->getConstexprKind(),

TrailingRequiresClause))

dyn_cast<CXXConversionDecl>(

)) {

importExplicitSpecifier(Err, FromConversion->getExplicitSpecifier());

std::move(Err);

(GetImportedOrCreateDecl<CXXConversionDecl>(

ToFunction,

, Importer.

(), cast<CXXRecordDecl>(DC),

ToInnerLocStart, NameInfo,

, TInfo,

->UsesFPIntrin(),

->isInlineSpecified(), ESpec,

->getConstexprKind(),

}

(

*Method = dyn_cast<CXXMethodDecl>(

)) {

(GetImportedOrCreateDecl<CXXMethodDecl>(

ToFunction,

, Importer.

(), cast<CXXRecordDecl>(DC),

ToInnerLocStart, NameInfo,

, TInfo, Method->getStorageClass(),

Method->UsesFPIntrin(), Method->isInlineSpecified(),

}

(

*Guide = dyn_cast<CXXDeductionGuideDecl>(

)) {

importExplicitSpecifier(Err, Guide->getExplicitSpecifier());

std::move(Err);

(GetImportedOrCreateDecl<CXXDeductionGuideDecl>(

ToFunction,

, Importer.

(), DC, ToInnerLocStart, ESpec,

NameInfo,

, TInfo, ToEndLoc, Ctor,

Guide->getDeductionCandidateKind(), TrailingRequiresClause,

(GetImportedOrCreateDecl(

ToFunction,

, Importer.

(), DC, ToInnerLocStart,

NameInfo,

, TInfo,

->getStorageClass(),

->UsesFPIntrin(),

->isInlineSpecified(),

->hasWrittenPrototype(),

->getConstexprKind(), TrailingRequiresClause))

(FoundByLookup) {

Imported =

(Msg);

Imported.takeError();

->FriendConstraintRefersToEnclosingTemplate());

(

*Param : Parameters) {

Param->setOwningFunction(ToFunction);

ToFunction->setParams(Parameters);

(

ProtoLoc =

(

I = 0, N = Parameters.size(); I != N; ++I)

ProtoLoc.setParam(I, Parameters[I]);

ToFTOrErr =

(FromFT);

ToFTOrErr.takeError();

(

*FromConstructor = dyn_cast<CXXConstructorDecl>(

)) {

(

NumInitializers = FromConstructor->getNumCtorInitializers()) {

FromConstructor->inits(), CtorInitializers))

std::move(Err);

std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);

*ToCtor = cast<CXXConstructorDecl>(ToFunction);

ToCtor->setCtorInitializers(Memory);

ToCtor->setNumCtorInitializers(NumInitializers);

std::move(Err);

(

*FromCXXMethod = dyn_cast<CXXMethodDecl>(

))

std::move(Err);

(

->doesThisDeclarationHaveABody()) {

std::move(Err);

(UsedDifferentProtoType) {

ToFunction->

(*TyOrErr);

TyOrErr.takeError();

TSIOrErr.takeError();

addDeclToContexts(

, ToFunction);

(++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {

ToRedeclOrErr.takeError();

std::move(Err);

FoundDecls = Importer.findDeclsInToCtx(DC, Name);

(

*FoundDecl : FoundDecls) {

(

*FoundField = dyn_cast<FieldDecl>(FoundDecl)) {

FoundField->getType())) {

(

*FromInitializer =

->getInClassInitializer()) {

(

ToInitializerOrErr =

(FromInitializer)) {

assert(FoundField->hasInClassInitializer() &&

);

(!FoundField->getInClassInitializer())

FoundField->setInClassInitializer(*ToInitializerOrErr);

ToInitializerOrErr.takeError();

Importer.

(

, diag::warn_odr_field_type_inconsistent)

<< Name <<

->getType() << FoundField->getType();

Importer.

(FoundField->getLocation(), diag::note_odr_value_here)

<< FoundField->getType();

Error Err = Error::success();

ToInnerLocStart =

(Err,

->getInnerLocStart());

std::move(Err);

*ToCapturedVLAType =

;

ToCapturedVLAType, cast_or_null<Type>(

->getCapturedVLAType())))

std::move(Err);

(GetImportedOrCreateDecl(ToField,

, Importer.

(), DC,

ToInnerLocStart,

, Name.getAsIdentifierInfo(),

ToType, ToTInfo, ToBitWidth,

->isMutable(),

->getInClassInitStyle()))

(ToCapturedVLAType)

ToInitializer =

(Err,

->getInClassInitializer());

std::move(Err);

(ToInitializer) {

(AlreadyImported)

assert(ToInitializer == AlreadyImported &&

);

std::move(Err);

FoundDecls = Importer.findDeclsInToCtx(DC, Name);

(

I = 0, N = FoundDecls.size(); I != N; ++I) {

(

*FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {

FoundField->getType(),

(!Name && I < N-1)

Importer.

(

, diag::warn_odr_field_type_inconsistent)

<< Name <<

->getType() << FoundField->getType();

Importer.

(FoundField->getLocation(), diag::note_odr_value_here)

<< FoundField->getType();

TypeOrErr =

(

->getType());

TypeOrErr.takeError();

(

*PI :

->chain())

NamedChain[i++] = *ToD;

ToD.takeError();

(GetImportedOrCreateDecl(ToIndirectField,

, Importer.

(), DC,

, Name.getAsIdentifierInfo(), *TypeOrErr, CH))

ToIndirectField;

ToIndirectField;

Ctx.IsEquivalent(FD1, FD2);

FriendCount = 0;

std::optional<unsigned int> FriendPosition;

(

*FoundFriend : RD->friends()) {

(FoundFriend == FD) {

FriendPosition = FriendCount;

assert(FriendPosition &&

);

{FriendCount, *FriendPosition};

std::move(Err);

*RD = cast<CXXRecordDecl>(DC);

(

*ImportedFriend : RD->friends())

ImportedEquivalentFriends.push_back(ImportedFriend);

assert(ImportedEquivalentFriends.size() <= CountAndPosition.

&&

);

(ImportedEquivalentFriends.size() == CountAndPosition.

)

, ImportedEquivalentFriends[CountAndPosition.

]);

(

*FriendD =

->getFriendDecl()) {

(Error Err = importInto(ToFriendD, FriendD))

std::move(Err);

(

TSIOrErr =

(

->getFriendType()))

TSIOrErr.takeError();

(

I = 0; I <

->NumTPLists; I++) {

(

ListOrErr =

(FromTPLists[I]))

ToTPLists[I] = *ListOrErr;

ListOrErr.takeError();

LocationOrErr.takeError();

FriendLocOrErr =

(

->getFriendLoc());

(!FriendLocOrErr)

FriendLocOrErr.takeError();

EllipsisLocOrErr =

(

->getEllipsisLoc());

(!EllipsisLocOrErr)

EllipsisLocOrErr.takeError();

(GetImportedOrCreateDecl(FrD,

, Importer.

(), DC,

*LocationOrErr, ToFU, *FriendLocOrErr,

*EllipsisLocOrErr, ToTPLists))

std::move(Err);

FoundDecls = Importer.findDeclsInToCtx(DC, Name);

(

*FoundDecl : FoundDecls) {

(

*FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {

FoundIvar->getType())) {

Importer.

(

, diag::warn_odr_ivar_type_inconsistent)

<< Name <<

->getType() << FoundIvar->getType();

Importer.

(FoundIvar->getLocation(), diag::note_odr_value_here)

<< FoundIvar->getType();

Error Err = Error::success();

ToTypeSourceInfo =

(Err,

->getTypeSourceInfo());

ToInnerLocStart =

(Err,

->getInnerLocStart());

std::move(Err);

(GetImportedOrCreateDecl(

ToIvar,

, Importer.

(), cast<ObjCContainerDecl>(DC),

ToInnerLocStart,

, Name.getAsIdentifierInfo(),

ToType, ToTypeSourceInfo,

->getAccessControl(),ToBitWidth,

->getSynthesize()))

RedeclIt = Redecls.begin();

(; RedeclIt != Redecls.end() && *RedeclIt !=

; ++RedeclIt) {

RedeclOrErr.takeError();

assert(*RedeclIt ==

);

std::move(Err);

*FoundByLookup =

;

(

->isFileVarDecl()) {

FoundDecls = Importer.findDeclsInToCtx(DC, Name);

(

*FoundDecl : FoundDecls) {

(

*FoundVar = dyn_cast<VarDecl>(FoundDecl)) {

FoundVar->getType())) {

(

->isThisDeclarationADefinition() && FoundDef)

*FoundDInit =

;

(

->getInit() && FoundVar->getAnyInitializer(FoundDInit))

FoundByLookup = FoundVar;

(FoundArray && TArray) {

(isa<IncompleteArrayType>(FoundArray) &&

isa<ConstantArrayType>(TArray)) {

(

TyOrErr =

(

->getType()))

FoundVar->setType(*TyOrErr);

TyOrErr.takeError();

FoundByLookup = FoundVar;

}

(isa<IncompleteArrayType>(TArray) &&

isa<ConstantArrayType>(FoundArray)) {

FoundByLookup = FoundVar;

Importer.

(

, diag::warn_odr_variable_type_inconsistent)

<< Name <<

->getType() << FoundVar->getType();

Importer.

(FoundVar->getLocation(), diag::note_odr_value_here)

<< FoundVar->getType();

ConflictingDecls.push_back(FoundDecl);

(!ConflictingDecls.empty()) {

Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());

Name = NameOrErr.get();

NameOrErr.takeError();

Error Err = Error::success();

ToTypeSourceInfo =

(Err,

->getTypeSourceInfo());

ToInnerLocStart =

(Err,

->getInnerLocStart());

ToQualifierLoc =

(Err,

->getQualifierLoc());

std::move(Err);

(

*FromDecomp = dyn_cast<DecompositionDecl>(

)) {

std::move(Err);

(GetImportedOrCreateDecl(

ToDecomp, FromDecomp, Importer.

(), DC, ToInnerLocStart,

, ToType, ToTypeSourceInfo,

->getStorageClass(),

))

(GetImportedOrCreateDecl(ToVar,

, Importer.

(), DC,

ToInnerLocStart,

,

Name.getAsIdentifierInfo(), ToType,

ToTypeSourceInfo,

->getStorageClass()))

(

->isInlineSpecified())

(

->isInline())

(FoundByLookup) {

(

->getDescribedVarTemplate()) {

ToVTOrErr =

(

->getDescribedVarTemplate());

ToVTOrErr.takeError();

*FromInst =

->getInstantiatedFromStaticDataMember();

ToInstOrErr.takeError();

(

POIOrErr =

(MSI->getPointOfInstantiation()))

POIOrErr.takeError();

std::move(Err);

(

->isConstexpr())

addDeclToContexts(

, ToVar);

(++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {

RedeclOrErr.takeError();

Error Err = Error::success();

std::move(Err);

(GetImportedOrCreateDecl(ToParm,

, Importer.

(), DC,

ToLocation, ToDeclName.getAsIdentifierInfo(),

ToType,

->getParameterKind()))

LocOrErr.takeError();

ToDefArgOrErr.takeError();

(

ToDefArgOrErr =

(FromParam->

()))

ToDefArgOrErr.takeError();

Error::success();

Error Err = Error::success();

std::move(Err);

Error Err = Error::success();

ToInnerLocStart =

(Err,

->getInnerLocStart());

ToTypeSourceInfo =

(Err,

->getTypeSourceInfo());

std::move(Err);

(GetImportedOrCreateDecl(ToParm,

, Importer.

(), DC,

ToInnerLocStart, ToLocation,

ToDeclName.getAsIdentifierInfo(), ToType,

ToTypeSourceInfo,

->getStorageClass(),

std::move(Err);

(

->isObjCMethodParameter()) {

->getFunctionScopeIndex());

std::move(Err);

FoundDecls = Importer.findDeclsInToCtx(DC, Name);

(

*FoundDecl : FoundDecls) {

(

*FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {

(FoundMethod->isInstanceMethod() !=

->isInstanceMethod())

FoundMethod->getReturnType())) {

Importer.

(

, diag::warn_odr_objc_method_result_type_inconsistent)

<<

->isInstanceMethod() << Name <<

->getReturnType()

<< FoundMethod->getReturnType();

Importer.

(FoundMethod->getLocation(),

diag::note_odr_objc_method_here)

<<

->isInstanceMethod() << Name;

(

->param_size() != FoundMethod->param_size()) {

Importer.

(

, diag::warn_odr_objc_method_num_params_inconsistent)

<<

->isInstanceMethod() << Name

<<

->param_size() << FoundMethod->param_size();

Importer.

(FoundMethod->getLocation(),

diag::note_odr_objc_method_here)

<<

->isInstanceMethod() << Name;

PEnd =

->param_end(), FoundP = FoundMethod->param_begin();

!= PEnd; ++

, ++FoundP) {

(*FoundP)->getType())) {

Importer.

((*P)->getLocation(),

diag::warn_odr_objc_method_param_type_inconsistent)

<<

->isInstanceMethod() << Name

<< (*P)->getType() << (*FoundP)->getType();

Importer.

((*FoundP)->getLocation(), diag::note_odr_value_here)

<< (*FoundP)->getType();

(

->isVariadic() != FoundMethod->isVariadic()) {

Importer.

(

, diag::warn_odr_objc_method_variadic_inconsistent)

<<

->isInstanceMethod() << Name;

Importer.

(FoundMethod->getLocation(),

diag::note_odr_objc_method_here)

<<

->isInstanceMethod() << Name;

Error Err = Error::success();

ToReturnTypeSourceInfo =

std::move(Err);

(GetImportedOrCreateDecl(

Name.getObjCSelector(), ToReturnType, ToReturnTypeSourceInfo, DC,

->isInstanceMethod(),

->isVariadic(),

->isPropertyAccessor(),

->isSynthesizedAccessorStub(),

->

(),

->isDefined(),

->getImplementationControl(),

->hasRelatedResultType()))

(

*FromP :

->parameters()) {

ToParams.push_back(*ToPOrErr);

ToPOrErr.takeError();

(

*ToParam : ToParams) {

ToParam->setOwningFunction(ToMethod);

->getSelectorLocs(FromSelLocs);

std::move(Err);

(

->getSelfDecl())

std::move(Err);

Error Err = Error::success();

ToTypeSourceInfo =

(Err,

->getTypeSourceInfo());

std::move(Err);

(GetImportedOrCreateDecl(

ToVarianceLoc,

->getIndex(),

ToLocation, Name.getAsIdentifierInfo(),

ToColonLoc, ToTypeSourceInfo))

std::move(Err);

->setTypeForDecl(ToTypeForDecl);

->setLexicalDeclContext(LexicalDC);

std::move(Err);

(Error Err = importInto(ToInterface,

->getClassInterface()))

std::move(Err);

Error Err = Error::success();

ToCategoryNameLoc =

(Err,

->getCategoryNameLoc());

ToIvarLBraceLoc =

(Err,

->getIvarLBraceLoc());

ToIvarRBraceLoc =

(Err,

->getIvarRBraceLoc());

std::move(Err);

(GetImportedOrCreateDecl(ToCategory,

, Importer.

(), DC,

Name.getAsIdentifierInfo(), ToInterface,

PListOrErr.takeError();

=

->protocol_loc_begin();

FromProtoEnd =

->protocol_end();

FromProto != FromProtoEnd;

++FromProto, ++FromProtoLoc) {

Protocols.push_back(*ToProtoOrErr);

ToProtoOrErr.takeError();

(

ToProtoLocOrErr =

(*FromProtoLoc))

ProtocolLocs.push_back(*ToProtoLocOrErr);

ToProtoLocOrErr.takeError();

std::move(Err);

(

->getImplementation()) {

(

->getImplementation()))

ToImplOrErr.takeError();

Error::success();

FromProto != FromProtoEnd;

++FromProto, ++FromProtoLoc) {

Protocols.push_back(*ToProtoOrErr);

ToProtoOrErr.takeError();

(

ToProtoLocOrErr =

(*FromProtoLoc))

ProtocolLocs.push_back(*ToProtoLocOrErr);

ToProtoLocOrErr.takeError();

Error::success();

ImportedDefOrErr.takeError();

std::move(Err);

FoundDecls = Importer.findDeclsInToCtx(DC, Name);

(

*FoundDecl : FoundDecls) {

((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl)))

ToAtBeginLocOrErr =

(

->getAtStartLoc());

(!ToAtBeginLocOrErr)

ToAtBeginLocOrErr.takeError();

(GetImportedOrCreateDecl(ToProto,

, Importer.

(), DC,

Name.getAsIdentifierInfo(),

,

(

->isThisDeclarationADefinition())

std::move(Err);

std::move(Err);

(!ExternLocOrErr)

ExternLocOrErr.takeError();

LangLocOrErr.takeError();

HasBraces =

->hasBraces();

(GetImportedOrCreateDecl(ToLinkageSpec,

, Importer.

(), DC,

*ExternLocOrErr, *LangLocOrErr,

->getLanguage(), HasBraces))

ToLinkageSpec;

(!RBraceLocOrErr)

RBraceLocOrErr.takeError();

ToLinkageSpec;

ToShadowOrErr.takeError();

std::move(Err);

Error Err = Error::success();

ToQualifierLoc =

(Err,

->getQualifierLoc());

std::move(Err);

std::move(Err);

(GetImportedOrCreateDecl(ToUsing,

, Importer.

(), DC,

ToUsingLoc, ToQualifierLoc, NameInfo,

ToUsing, *ToPatternOrErr);

ToPatternOrErr.takeError();

std::move(Err);

Error Err = Error::success();

std::move(Err);

(GetImportedOrCreateDecl(ToUsingEnum,

, Importer.

(), DC,

ToUsingLoc, ToEnumLoc, ToNameLoc, ToEnumType))

ToPatternOrErr.takeError();

std::move(Err);

(!ToIntroducerOrErr)

ToIntroducerOrErr.takeError();

ToTargetOrErr.takeError();

(

*FromConstructorUsingShadow =

dyn_cast<ConstructorUsingShadowDecl>(

)) {

Error Err = Error::success();

Err, FromConstructorUsingShadow->getNominatedBaseClassShadowDecl());

std::move(Err);

(GetImportedOrCreateDecl<ConstructorUsingShadowDecl>(

cast<UsingDecl>(*ToIntroducerOrErr),

Nominated ? Nominated : *ToTargetOrErr,

FromConstructorUsingShadow->constructsVirtualBase()))

(GetImportedOrCreateDecl(ToShadow,

, Importer.

(), DC,

,

Name, *ToIntroducerOrErr, *ToTargetOrErr))

ToShadow, *ToPatternOrErr);

ToPatternOrErr.takeError();

std::move(Err);

ToComAncestorOrErr = Importer.

(

->getCommonAncestor());

(!ToComAncestorOrErr)

ToComAncestorOrErr.takeError();

Error Err = Error::success();

ToNominatedNamespace =

(Err,

->getNominatedNamespace());

ToNamespaceKeyLocation =

ToQualifierLoc =

(Err,

->getQualifierLoc());

ToIdentLocation =

(Err,

->getIdentLocation());

std::move(Err);

(GetImportedOrCreateDecl(ToUsingDir,

, Importer.

(), DC,

ToNamespaceKeyLocation,

ToNominatedNamespace, *ToComAncestorOrErr))

std::move(Err);

ToInstantiatedFromUsingOrErr =

Importer.

(

->getInstantiatedFromUsingDecl());

(!ToInstantiatedFromUsingOrErr)

ToInstantiatedFromUsingOrErr.takeError();

std::move(Err);

(GetImportedOrCreateDecl(ToUsingPack,

, Importer.

(), DC,

cast<NamedDecl>(*ToInstantiatedFromUsingOrErr),

addDeclToContexts(

, ToUsingPack);

std::move(Err);

Error Err = Error::success();

ToQualifierLoc =

(Err,

->getQualifierLoc());

std::move(Err);

std::move(Err);

(GetImportedOrCreateDecl(ToUsingValue,

, Importer.

(), DC,

ToUsingLoc, ToQualifierLoc, NameInfo,

ToUsingValue;

ToUsingValue;

std::move(Err);

Error Err = Error::success();

ToQualifierLoc =

(Err,

->getQualifierLoc());

std::move(Err);

(GetImportedOrCreateDecl(ToUsing,

, Importer.

(), DC,

ToUsingLoc, ToTypenameLoc,

ToQualifierLoc,

, Name, ToEllipsisLoc))

* ToD =

;

(

->getBuiltinTemplateKind()) {

assert(ToD &&

);

(

FromSuperOrErr =

(FromSuper))

FromSuper = *FromSuperOrErr;

FromSuperOrErr.takeError();

((

)FromSuper != (

)ToSuper ||

diag::warn_odr_objc_superclass_inconsistent)

diag::note_odr_objc_missing_superclass);

diag::note_odr_objc_superclass)

diag::note_odr_objc_missing_superclass);

Error::success();

SuperTInfoOrErr.takeError();

FromProto != FromProtoEnd;

++FromProto, ++FromProtoLoc) {

Protocols.push_back(*ToProtoOrErr);

ToProtoOrErr.takeError();

(

ToProtoLocOrErr =

(*FromProtoLoc))

ProtocolLocs.push_back(*ToProtoLocOrErr);

ToProtoLocOrErr.takeError();

ToCatOrErr =

(Cat);

ToCatOrErr.takeError();

ToImplOrErr.takeError();

Error::success();

(

*fromTypeParam : *list) {

(

toTypeParamOrErr =

(fromTypeParam))

toTypeParams.push_back(*toTypeParamOrErr);

toTypeParamOrErr.takeError();

(!LAngleLocOrErr)

LAngleLocOrErr.takeError();

(!RAngleLocOrErr)

RAngleLocOrErr.takeError();

ImportedDefOrErr.takeError();

std::move(Err);

FoundDecls = Importer.findDeclsInToCtx(DC, Name);

(

*FoundDecl : FoundDecls) {

((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecl)))

AtBeginLocOrErr =

(

->getAtStartLoc());

(!AtBeginLocOrErr)

AtBeginLocOrErr.takeError();

(GetImportedOrCreateDecl(

*AtBeginLocOrErr, Name.getAsIdentifierInfo(),

,

,

->isImplicitInterfaceDecl()))

(

ToPListOrErr =

ToPListOrErr.takeError();

(

->isThisDeclarationADefinition())

std::move(Err);

(Error Err = importInto(

,

->getCategoryDecl()))

std::move(Err);

std::move(Err);

Error Err = Error::success();

ToCategoryNameLoc =

(Err,

->getCategoryNameLoc());

std::move(Err);

(GetImportedOrCreateDecl(

Importer.

(

->getIdentifier()),

->getClassInterface(),

ToLocation, ToAtStartLoc, ToCategoryNameLoc))

->setImplementation(ToImpl);

std::move(Err);

(Error Err = importInto(Iface,

->getClassInterface()))

std::move(Err);

(Error Err = importInto(Super,

->getSuperClass()))

std::move(Err);

std::move(Err);

Error Err = Error::success();

ToSuperClassLoc =

(Err,

->getSuperClassLoc());

ToIvarLBraceLoc =

(Err,

->getIvarLBraceLoc());

ToIvarRBraceLoc =

(Err,

->getIvarRBraceLoc());

std::move(Err);

(GetImportedOrCreateDecl(Impl,

, Importer.

(),

diag::warn_odr_objc_superclass_inconsistent)

diag::note_odr_objc_superclass)

diag::note_odr_objc_missing_superclass);

(

->getSuperClass())

diag::note_odr_objc_superclass)

<<

->getSuperClass()->getDeclName();

diag::note_odr_objc_missing_superclass);

std::move(Err);

std::move(Err);

FoundDecls = Importer.findDeclsInToCtx(DC, Name);

(

*FoundDecl : FoundDecls) {

(

*FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) {

(FoundProp->isInstanceProperty() !=

->isInstanceProperty())

FoundProp->getType())) {

Importer.

(

, diag::warn_odr_objc_property_type_inconsistent)

<< Name <<

->getType() << FoundProp->getType();

Importer.

(FoundProp->getLocation(), diag::note_odr_value_here)

<< FoundProp->getType();

Error Err = Error::success();

ToTypeSourceInfo =

(Err,

->getTypeSourceInfo());

std::move(Err);

(GetImportedOrCreateDecl(

Name.getAsIdentifierInfo(), ToAtLoc,

ToLParenLoc, ToType,

ToTypeSourceInfo,

->getPropertyImplementation()))

ToGetterNameLoc =

(Err,

->getGetterNameLoc());

ToSetterNameLoc =

(Err,

->getSetterNameLoc());

ToGetterMethodDecl =

(Err,

->getGetterMethodDecl());

ToSetterMethodDecl =

(Err,

->getSetterMethodDecl());

ToPropertyIvarDecl =

(Err,

->getPropertyIvarDecl());

std::move(Err);

->getPropertyAttributesAsWritten());

(Error Err = importInto(

,

->getPropertyDecl()))

std::move(Err);

std::move(Err);

*InImpl = cast<ObjCImplDecl>(LexicalDC);

(Error Err = importInto(Ivar,

->getPropertyIvarDecl()))

std::move(Err);

= InImpl->FindPropertyImplDecl(

->getIdentifier(),

Error Err = Error::success();

ToPropertyIvarDeclLoc =

std::move(Err);

(GetImportedOrCreateDecl(ToImpl,

, Importer.

(), DC,

->getPropertyImplementation(), Ivar,

ToPropertyIvarDeclLoc))

diag::warn_odr_objc_property_impl_kind_inconsistent)

diag::note_odr_objc_property_impl_kind)

<<

->getPropertyDecl()->getDeclName()

diag::warn_odr_objc_synthesize_ivar_inconsistent)

Importer.

(

->getPropertyIvarDeclLoc(),

diag::note_odr_objc_synthesize_ivar_here)

<<

->getPropertyIvarDecl()->getDeclName();

BeginLocOrErr.takeError();

LocationOrErr.takeError();

(GetImportedOrCreateDecl(

*BeginLocOrErr, *LocationOrErr,

->getDepth(),

->getIndex(), Importer.

(

->getIdentifier()),

->hasTypeConstraint()))

Error Err = Error::success();

ToConceptRef =

(Err, TC->getConceptReference());

ToIDC =

(Err, TC->getImmediatelyDeclaredConstraint());

std::move(Err);

(Error Err = importTemplateParameterDefaultArgument(

, ToD))

Error Err = Error::success();

ToTypeSourceInfo =

(Err,

->getTypeSourceInfo());

ToInnerLocStart =

(Err,

->getInnerLocStart());

std::move(Err);

(GetImportedOrCreateDecl(ToD,

, Importer.

(),

ToInnerLocStart, ToLocation,

->getDepth(),

ToDeclName.getAsIdentifierInfo(), ToType,

Err = importTemplateParameterDefaultArgument(

, ToD);

NameOrErr =

(

->getDeclName());

NameOrErr.takeError();

LocationOrErr.takeError();

TemplateParamsOrErr =

(

->getTemplateParameters());

(!TemplateParamsOrErr)

TemplateParamsOrErr.takeError();

(GetImportedOrCreateDecl(

(*NameOrErr).getAsIdentifierInfo(),

->wasDeclaredWithTypename(),

*TemplateParamsOrErr))

(Error Err = importTemplateParameterDefaultArgument(

, ToD))

assert(

->getTemplatedDecl() &&

);

*ToTemplatedDef =

->getTemplatedDecl()->getDefinition();

(!ToTemplatedDef)

cast_or_null<T>(TemplateWithDef);

std::move(Err);

DependentFriend = IsDependentFriend(

);

FoundDecls = Importer.findDeclsInToCtx(DC, Name);

(

*FoundDecl : FoundDecls) {

*FoundTemplate = dyn_cast<ClassTemplateDecl>(FoundDecl);

(FoundTemplate) {

IgnoreTemplateParmDepth =

IgnoreTemplateParmDepth)) {

(DependentFriend || IsDependentFriend(FoundTemplate))

(

->isThisDeclarationADefinition() && TemplateWithDef)

FoundByLookup = FoundTemplate;

ConflictingDecls.push_back(FoundDecl);

(!ConflictingDecls.empty()) {

ConflictingDecls.size());

Name = NameOrErr.get();

NameOrErr.takeError();

TemplateParamsOrErr =

(

->getTemplateParameters());

(!TemplateParamsOrErr)

TemplateParamsOrErr.takeError();

(Error Err = importInto(ToTemplated, FromTemplated))

std::move(Err);

(GetImportedOrCreateDecl(D2,

, Importer.

(), DC,

, Name,

*TemplateParamsOrErr, ToTemplated))

addDeclToContexts(

, D2);

updateLookupTableForTemplateParameters(**TemplateParamsOrErr);

(FoundByLookup) {

);

(ToTemplated != PrevTemplated)

(Error Err = importInto(ClassTemplate,

->getSpecializedTemplate()))

std::move(Err);

std::move(Err);

std::move(Err);

*InsertPos =

;

dyn_cast<ClassTemplatePartialSpecializationDecl>(

);

ToTPListOrErr.takeError();

ToTPList = *ToTPListOrErr;

(

->isThisDeclarationADefinition() && PrevDefinition) {

(

*FromField :

->fields()) {

ToOrErr =

(FromField);

ToOrErr.takeError();

ToOrErr =

(FromM);

ToOrErr.takeError();

PrevDefinition;

BeginLocOrErr.takeError();

IdLocOrErr.takeError();

(

*ASTTemplateArgs =

->getTemplateArgsAsWritten()) {

std::move(Err);

(Error Err = importInto(

std::move(Err);

(GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>(

D2,

, Importer.

(),

->getTagKind(), DC, *BeginLocOrErr,

*IdLocOrErr, ToTPList, ClassTemplate,

cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl)))

*PartSpec2 = cast<ClassTemplatePartialSpecializationDecl>(D2);

PartSpec2->setInstantiatedFromMember(*ToInstOrErr);

ToInstOrErr.takeError();

updateLookupTableForTemplateParameters(*ToTPList);

(GetImportedOrCreateDecl(

*BeginLocOrErr, *IdLocOrErr, ClassTemplate, TemplateArgs,

(

BraceRangeOrErr =

(

->getBraceRange()))

BraceRangeOrErr.takeError();

std::move(Err);

(

LocOrErr =

(

->getQualifierLoc()))