Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2025-01-12 02:47:10 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

[AST] Print correct tag decl for tag specifier

Browse Source 
For example, given:

  void fn() {
    struct T *p0;
    struct T { int i; } *p1;
  }

-ast-print produced:

  void fn() {
    struct T { int i; } *p0;
    struct T { int i; } *p1;
  }

Compiling that fails with a redefinition error.

Given:

  void fn() {
    struct T *p0;
    struct __attribute__((deprecated)) T *p1;
  }

-ast-print dropped the attribute.

Details:

For a tag specifier (that is, struct/union/class/enum used as a type
specifier in a declaration) that was also a tag declaration (that is,
first occurrence of the tag) or tag redeclaration (that is, later
occurrence that specifies attributes or a member list), clang printed
the tag specifier as either (1) the full tag definition if one
existed, or (2) the first tag declaration otherwise.  Redefinition
errors were sometimes introduced, as in the first example above.  Even
when that was impossible because no member list was ever specified,
attributes were sometimes lost, thus changing semantics and
diagnostics, as in the second example above.

This patch fixes a major culprit for these problems.  It does so by
creating an ElaboratedType with a new OwnedDecl member wherever an
occurrence of a tag type is a (re)declaration of that tag type.
PrintingPolicy's IncludeTagDefinition used to trigger printing of the
member list, attributes, etc. for a tag specifier by using a tag
(re)declaration selected as described above.  Now, it triggers the
same thing except it uses the tag (re)declaration stored in the
OwnedDecl.  Of course, other tooling can now make use of the new
OwnedDecl as well.

Also, to be more faithful to the original source, this patch
suppresses printing of attributes inherited from previous
declarations.

Reviewed by: rsmith, aaron.ballman

Differential Revision: https://reviews.llvm.org/D45463

llvm-svn: 332281
This commit is contained in:
Joel E. Denny 2018-05-14 19:36:45 +00:00
parent 9668e45b61
commit 7509a2f5cc
12 changed files with 380 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
clang/include/clang/AST/ASTContext.h
View File

@ -1419,8 +1419,8 @@ public:
QualType getParenType(QualType NamedType) const;
QualType getElaboratedType(ElaboratedTypeKeyword Keyword,
NestedNameSpecifier *NNS,
QualType NamedType) const;
NestedNameSpecifier *NNS, QualType NamedType,
TagDecl *OwnedTagDecl = nullptr) const;
QualType getDependentNameType(ElaboratedTypeKeyword Keyword,
NestedNameSpecifier *NNS,
const IdentifierInfo *Name,

19
clang/include/clang/AST/Type.h
View File

@ -56,6 +56,7 @@ namespace clang {
class ExtQuals;
class QualType;
class TagDecl;
class Type;
enum {
@ -4865,14 +4866,18 @@ class ElaboratedType : public TypeWithKeyword, public llvm::FoldingSetNode {
/// The type that this qualified name refers to.
QualType NamedType;
/// The (re)declaration of this tag type owned by this occurrence, or nullptr
/// if none.
TagDecl *OwnedTagDecl;
ElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
QualType NamedType, QualType CanonType)
QualType NamedType, QualType CanonType, TagDecl *OwnedTagDecl)
: TypeWithKeyword(Keyword, Elaborated, CanonType,
NamedType->isDependentType(),
NamedType->isInstantiationDependentType(),
NamedType->isVariablyModifiedType(),
NamedType->containsUnexpandedParameterPack()),
NNS(NNS), NamedType(NamedType) {
NNS(NNS), NamedType(NamedType), OwnedTagDecl(OwnedTagDecl) {
assert(!(Keyword == ETK_None && NNS == nullptr) &&
"ElaboratedType cannot have elaborated type keyword "
"and name qualifier both null.");
@ -4893,15 +4898,21 @@ public:
/// Returns whether this type directly provides sugar.
bool isSugared() const { return true; }
/// Return the (re)declaration of this type owned by this occurrence of this
/// type, or nullptr if none.
TagDecl *getOwnedTagDecl() const { return OwnedTagDecl; }
void Profile(llvm::FoldingSetNodeID &ID) {
Profile(ID, getKeyword(), NNS, NamedType);
Profile(ID, getKeyword(), NNS, NamedType, OwnedTagDecl);
}
static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
NestedNameSpecifier *NNS, QualType NamedType) {
NestedNameSpecifier *NNS, QualType NamedType,
TagDecl *OwnedTagDecl) {
ID.AddInteger(Keyword);
ID.AddPointer(NNS);
NamedType.Profile(ID);
ID.AddPointer(OwnedTagDecl);
}
static bool classof(const Type *T) {

3
clang/include/clang/Sema/Sema.h
View File

@ -1638,7 +1638,8 @@ public:
}
QualType getElaboratedType(ElaboratedTypeKeyword Keyword,
const CXXScopeSpec &SS, QualType T);
const CXXScopeSpec &SS, QualType T,
TagDecl *OwnedTagDecl = nullptr);
QualType BuildTypeofExprType(Expr *E, SourceLocation Loc);
/// If AsUnevaluated is false, E is treated as though it were an evaluated

13
clang/lib/AST/ASTContext.cpp
View File

@ -3979,12 +3979,12 @@ QualType ASTContext::getCanonicalTemplateSpecializationType(
return QualType(Spec, 0);
}
QualType
ASTContext::getElaboratedType(ElaboratedTypeKeyword Keyword,
NestedNameSpecifier *NNS,
QualType NamedType) const {
QualType ASTContext::getElaboratedType(ElaboratedTypeKeyword Keyword,
NestedNameSpecifier *NNS,
QualType NamedType,
TagDecl *OwnedTagDecl) const {
llvm::FoldingSetNodeID ID;
ElaboratedType::Profile(ID, Keyword, NNS, NamedType);
ElaboratedType::Profile(ID, Keyword, NNS, NamedType, OwnedTagDecl);
void *InsertPos = nullptr;
ElaboratedType *T = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
@ -3999,7 +3999,8 @@ ASTContext::getElaboratedType(ElaboratedTypeKeyword Keyword,
(void)CheckT;
}
T = new (*this, TypeAlignment) ElaboratedType(Keyword, NNS, NamedType, Canon);
T = new (*this, TypeAlignment)
ElaboratedType(Keyword, NNS, NamedType, Canon, OwnedTagDecl);
Types.push_back(T);
ElaboratedTypes.InsertNode(T, InsertPos);
return QualType(T, 0);

8
clang/lib/AST/ASTImporter.cpp
View File

@ -908,8 +908,14 @@ QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
if (ToNamedType.isNull())
return {};
TagDecl *OwnedTagDecl =
cast_or_null<TagDecl>(Importer.Import(T->getOwnedTagDecl()));
if (!OwnedTagDecl && T->getOwnedTagDecl())
return {};
return Importer.getToContext().getElaboratedType(T->getKeyword(),
ToQualifier, ToNamedType);
ToQualifier, ToNamedType,
OwnedTagDecl);
}
QualType ASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) {

2
clang/lib/AST/DeclPrinter.cpp
View File

@ -215,6 +215,8 @@ void DeclPrinter::prettyPrintAttributes(Decl *D) {
if (D->hasAttrs()) {
AttrVec &Attrs = D->getAttrs();
for (auto *A : Attrs) {
if (A->isInherited())
continue;
switch (A->getKind()) {
#define ATTR(X)
#define PRAGMA_SPELLING_ATTR(X) case attr::X:

13
clang/lib/AST/TypePrinter.cpp
View File

@ -1209,6 +1209,17 @@ void TypePrinter::printInjectedClassNameAfter(const InjectedClassNameType *T,
void TypePrinter::printElaboratedBefore(const ElaboratedType *T,
raw_ostream &OS) {
if (Policy.IncludeTagDefinition && T->getOwnedTagDecl()) {
TagDecl *OwnedTagDecl = T->getOwnedTagDecl();
assert(OwnedTagDecl->getTypeForDecl() == T->getNamedType().getTypePtr() &&
"OwnedTagDecl expected to be a declaration for the type");
PrintingPolicy SubPolicy = Policy;
SubPolicy.IncludeTagDefinition = false;
OwnedTagDecl->print(OS, SubPolicy, Indentation);
spaceBeforePlaceHolder(OS);
return;
}
// The tag definition will take care of these.
if (!Policy.IncludeTagDefinition)
{
@ -1226,6 +1237,8 @@ void TypePrinter::printElaboratedBefore(const ElaboratedType *T,
void TypePrinter::printElaboratedAfter(const ElaboratedType *T,
raw_ostream &OS) {
if (Policy.IncludeTagDefinition && T->getOwnedTagDecl())
return;
ElaboratedTypePolicyRAII PolicyRAII(Policy);
printAfter(T->getNamedType(), OS);
}

15
clang/lib/Sema/SemaType.cpp
View File

@ -1429,7 +1429,7 @@ static QualType ConvertDeclSpecToType(TypeProcessingState &state) {
case DeclSpec::TST_union:
case DeclSpec::TST_struct:
case DeclSpec::TST_interface: {
TypeDecl *D = dyn_cast_or_null<TypeDecl>(DS.getRepAsDecl());
TagDecl *D = dyn_cast_or_null<TagDecl>(DS.getRepAsDecl());
if (!D) {
// This can happen in C++ with ambiguous lookups.
Result = Context.IntTy;
@ -1449,7 +1449,8 @@ static QualType ConvertDeclSpecToType(TypeProcessingState &state) {
// In both C and C++, make an ElaboratedType.
ElaboratedTypeKeyword Keyword
= ElaboratedType::getKeywordForTypeSpec(DS.getTypeSpecType());
Result = S.getElaboratedType(Keyword, DS.getTypeSpecScope(), Result);
Result = S.getElaboratedType(Keyword, DS.getTypeSpecScope(), Result,
DS.isTypeSpecOwned() ? D : nullptr);
break;
}
case DeclSpec::TST_typename: {
@ -7863,10 +7864,12 @@ bool Sema::RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID) {
return RequireLiteralType(Loc, T, Diagnoser);
}
/// Retrieve a version of the type 'T' that is elaborated by Keyword
/// and qualified by the nested-name-specifier contained in SS.
/// Retrieve a version of the type 'T' that is elaborated by Keyword, qualified
/// by the nested-name-specifier contained in SS, and that is (re)declared by
/// OwnedTagDecl, which is nullptr if this is not a (re)declaration.
QualType Sema::getElaboratedType(ElaboratedTypeKeyword Keyword,
const CXXScopeSpec &SS, QualType T) {
const CXXScopeSpec &SS, QualType T,
TagDecl *OwnedTagDecl) {
if (T.isNull())
return T;
NestedNameSpecifier *NNS;
@ -7877,7 +7880,7 @@ QualType Sema::getElaboratedType(ElaboratedTypeKeyword Keyword,
return T;
NNS = nullptr;
}
return Context.getElaboratedType(Keyword, NNS, T);
return Context.getElaboratedType(Keyword, NNS, T, OwnedTagDecl);
}
QualType Sema::BuildTypeofExprType(Expr *E, SourceLocation Loc) {

3
clang/lib/Serialization/ASTReader.cpp
View File

@ -6185,7 +6185,8 @@ QualType ASTReader::readTypeRecord(unsigned Index) {
ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
QualType NamedType = readType(*Loc.F, Record, Idx);
return Context.getElaboratedType(Keyword, NNS, NamedType);
TagDecl *OwnedTagDecl = ReadDeclAs<TagDecl>(*Loc.F, Record, Idx);
return Context.getElaboratedType(Keyword, NNS, NamedType, OwnedTagDecl);
}
case TYPE_OBJC_INTERFACE: {

1
clang/lib/Serialization/ASTWriter.cpp
View File

@ -512,6 +512,7 @@ void ASTTypeWriter::VisitElaboratedType(const ElaboratedType *T) {
Record.push_back(T->getKeyword());
Record.AddNestedNameSpecifier(T->getQualifier());
Record.AddTypeRef(T->getNamedType());
Record.AddDeclRef(T->getOwnedTagDecl());
Code = TYPE_ELABORATED;
}

85
clang/test/Misc/ast-print-enum-decl.c Normal file
View File

@ -0,0 +1,85 @@
// First check compiling and printing of this file.
//
// RUN: %clang_cc1 -verify -ast-print %s > %t.c
// RUN: FileCheck --check-prefixes=CHECK,PRINT %s --input-file %t.c
//
// Now check compiling and printing of the printed file.
//
// RUN: echo "// expected""-warning@* 6 {{'T' is deprecated}}" >> %t.c
// RUN: echo "// expected""-note@* 6 {{'T' has been explicitly marked deprecated here}}" >> %t.c
//
// RUN: %clang_cc1 -verify -ast-print %t.c \
// RUN: | FileCheck --check-prefixes=CHECK,PRINT %s
// END.
// CHECK-LABEL: defFirst
void defFirst() {
// PRINT-NEXT: enum
// PRINT-DAG: __attribute__((aligned(16)))
// PRINT-DAG: __attribute__((deprecated("")))
// PRINT-SAME: T {
// PRINT-NEXT: E0,
// PRINT-NEXT: E1
// PRINT-NEXT: } *p0;
// expected-warning@+2 {{'T' is deprecated}}
// expected-note@+1 2 {{'T' has been explicitly marked deprecated here}}
enum __attribute__((aligned(16))) __attribute__((deprecated(""))) T {
E0, E1
} *p0;
// PRINT-NEXT: enum T *p1;
enum T *p1; // expected-warning {{'T' is deprecated}}
}
// CHECK-LABEL: defLast
void defLast() {
// PRINT-NEXT: enum __attribute__((aligned(16))) T *p0;
enum __attribute__((aligned(16))) T *p0;
// PRINT-NEXT: enum __attribute__((deprecated(""))) T {
// PRINT-NEXT: E0,
// PRINT-NEXT: E1
// PRINT-NEXT: } *p1;
// expected-warning@+2 {{'T' is deprecated}}
// expected-note@+1 {{'T' has been explicitly marked deprecated here}}
enum __attribute__((deprecated(""))) T { E0, E1 } *p1;
}
// CHECK-LABEL: defMiddle
void defMiddle() {
// PRINT-NEXT: enum __attribute__((deprecated(""))) T *p0;
// expected-warning@+2 {{'T' is deprecated}}
// expected-note@+1 3 {{'T' has been explicitly marked deprecated here}}
enum __attribute__((deprecated(""))) T *p0;
// PRINT-NEXT: enum __attribute__((aligned(16))) T {
// PRINT-NEXT: E0
// PRINT-NEXT: E1
// PRINT-NEXT: } *p1;
enum __attribute__((aligned(16))) T { E0, E1 } *p1; // expected-warning {{'T' is deprecated}}
// PRINT-NEXT: enum T *p2;
enum T *p2; // expected-warning {{'T' is deprecated}}
}
// CHECK-LABEL: declsOnly
void declsOnly() {
// FIXME: For some reason, attributes are ignored if they're not on the first
// declaration and not on the definition.
// PRINT-NEXT: enum __attribute__((aligned)) T *p0;
enum __attribute__((aligned)) T *p0;
// PRINT-NEXT: enum T *p1;
enum __attribute__((may_alias)) T *p1;
// PRINT-NEXT: enum T *p2;
enum T *p2;
// PRINT-NEXT: enum T *p3;
enum __attribute__((deprecated(""))) T *p3;
// PRINT-NEXT: enum T *p4;
enum T *p4;
}

235
clang/test/Misc/ast-print-record-decl.c Normal file
View File

@ -0,0 +1,235 @@
// Check struct:
//
// First check compiling and printing of this file.
//
// RUN: %clang -Xclang -verify -S -emit-llvm -DKW=struct -DBASES= -o - %s \
// RUN: | FileCheck --check-prefixes=CHECK,LLVM %s
//
// RUN: %clang_cc1 -verify -ast-print -DKW=struct -DBASES= %s > %t.c
// RUN: FileCheck --check-prefixes=CHECK,PRINT -DKW=struct -DBASES= %s \
// RUN: --input-file %t.c
//
// Now check compiling and printing of the printed file.
//
// RUN: echo "// expected""-warning@* 10 {{'T' is deprecated}}" >> %t.c
// RUN: echo "// expected""-note@* 10 {{'T' has been explicitly marked deprecated here}}" >> %t.c
//
// RUN: %clang -Xclang -verify -S -emit-llvm -o - %t.c \
// RUN: | FileCheck --check-prefixes=CHECK,LLVM %s
//
// RUN: %clang_cc1 -verify -ast-print %t.c \
// RUN: | FileCheck --check-prefixes=CHECK,PRINT -DKW=struct -DBASES= %s
// Repeat for union:
//
// First check compiling and printing of this file.
//
// RUN: %clang -Xclang -verify -S -emit-llvm -DKW=union -DBASES= -o - %s \
// RUN: | FileCheck --check-prefixes=CHECK,LLVM %s
//
// RUN: %clang_cc1 -verify -ast-print -DKW=union -DBASES= %s > %t.c
// RUN: FileCheck --check-prefixes=CHECK,PRINT -DKW=union -DBASES= %s \
// RUN: --input-file %t.c
//
// Now check compiling and printing of the printed file.
//
// RUN: echo "// expected""-warning@* 10 {{'T' is deprecated}}" >> %t.c
// RUN: echo "// expected""-note@* 10 {{'T' has been explicitly marked deprecated here}}" >> %t.c
//
// RUN: %clang -Xclang -verify -S -emit-llvm -o - %t.c \
// RUN: | FileCheck --check-prefixes=CHECK,LLVM %s
//
// RUN: %clang_cc1 -verify -ast-print %t.c \
// RUN: | FileCheck --check-prefixes=CHECK,PRINT -DKW=union -DBASES= %s
// Repeat for C++ (BASES helps ensure we're printing as C++ not as C):
//
// First check compiling and printing of this file.
//
// RUN: %clang -Xclang -verify -S -emit-llvm -DKW=struct -DBASES=' : B' -o - \
// RUN: -xc++ %s \
// RUN: | FileCheck --check-prefixes=CHECK,LLVM %s
//
// RUN: %clang_cc1 -verify -ast-print -DKW=struct -DBASES=' : B' -xc++ %s \
// RUN: > %t.cpp
// RUN: FileCheck --check-prefixes=CHECK,PRINT,CXX -DKW=struct \
// RUN: -DBASES=' : B' %s --input-file %t.cpp
//
// Now check compiling and printing of the printed file.
//
// RUN: echo "// expected""-warning@* 10 {{'T' is deprecated}}" >> %t.cpp
// RUN: echo "// expected""-note@* 10 {{'T' has been explicitly marked deprecated here}}" >> %t.cpp
//
// RUN: %clang -Xclang -verify -S -emit-llvm -o - %t.cpp \
// RUN: | FileCheck --check-prefixes=CHECK,LLVM %s
//
// RUN: %clang_cc1 -verify -ast-print %t.cpp \
// RUN: | FileCheck --check-prefixes=CHECK,PRINT,CXX -DKW=struct \
// RUN: -DBASES=' : B' %s
// END.
#ifndef KW
# error KW undefined
# define KW struct // help syntax checkers
#endif
#ifndef BASES
# error BASES undefined
# define BASES // help syntax checkers
#endif
struct B {};
// CHECK-LABEL: defFirst
void defFirst() {
// PRINT-NEXT: [[KW]]
// PRINT-DAG: __attribute__((aligned(16)))
// PRINT-DAG: __attribute__((deprecated("")))
// PRINT-NOT: __attribute__
// PRINT-SAME: T[[BASES]] {
// PRINT-NEXT: int i;
// PRINT-NEXT: } *p0;
// expected-warning@+2 {{'T' is deprecated}}
// expected-note@+1 2 {{'T' has been explicitly marked deprecated here}}
KW __attribute__((aligned(16))) __attribute__((deprecated(""))) T BASES {
int i;
} *p0;
// PRINT-NEXT: [[KW]] T *p1;
KW T *p1; // expected-warning {{'T' is deprecated}}
// LLVM: store i64 16
long s0 = sizeof *p0;
// LLVM-NEXT: store i64 16
long s1 = sizeof *p1;
}
// CHECK-LABEL: defLast
void defLast() {
// PRINT-NEXT: [[KW]] __attribute__((aligned(16))) T *p0;
KW __attribute__((aligned(16))) T *p0;
// PRINT-NEXT: [[KW]] __attribute__((deprecated(""))) T[[BASES]] {
// PRINT-NEXT: int i;
// PRINT-NEXT: } *p1;
// expected-warning@+2 {{'T' is deprecated}}
// expected-note@+1 {{'T' has been explicitly marked deprecated here}}
KW __attribute__((deprecated(""))) T BASES { int i; } *p1;
// LLVM: store i64 16
long s0 = sizeof *p0;
// LLVM-NEXT: store i64 16
long s1 = sizeof *p1;
}
// CHECK-LABEL: defMiddle
void defMiddle() {
// PRINT-NEXT: [[KW]] __attribute__((deprecated(""))) T *p0;
// expected-warning@+2 {{'T' is deprecated}}
// expected-note@+1 3 {{'T' has been explicitly marked deprecated here}}
KW __attribute__((deprecated(""))) T *p0;
// PRINT-NEXT: [[KW]] __attribute__((aligned(16))) T[[BASES]] {
// PRINT-NEXT: int i;
// PRINT-NEXT: } *p1;
KW __attribute__((aligned(16))) T BASES { int i; } *p1; // expected-warning {{'T' is deprecated}}
// PRINT-NEXT: [[KW]] T *p2;
KW T *p2; // expected-warning {{'T' is deprecated}}
// LLVM: store i64 16
long s0 = sizeof *p0;
// LLVM-NEXT: store i64 16
long s1 = sizeof *p1;
// LLVM-NEXT: store i64 16
long s2 = sizeof *p2;
}
// CHECK-LABEL: defSelfRef
void defSelfRef() {
// PRINT-NEXT: [[KW]] __attribute__((deprecated(""))) T *p0;
// expected-warning@+2 {{'T' is deprecated}}
// expected-note@+1 2 {{'T' has been explicitly marked deprecated here}}
KW __attribute__((deprecated(""))) T *p0;
// PRINT-NEXT: [[KW]] __attribute__((aligned(16))) T[[BASES]] {
// PRINT-NEXT: int i;
// PRINT-NEXT: [[KW]] T *p2;
// PRINT-NEXT: } *p1;
KW __attribute__((aligned(16))) T BASES { // expected-warning {{'T' is deprecated}}
int i;
KW T *p2;
} *p1;
// LLVM: store i64 16
long s0 = sizeof *p0;
// LLVM-NEXT: store i64 16
long s1 = sizeof *p1;
// LLVM-NEXT: store i64 16
long s2 = sizeof *p0->p2;
// LLVM-NEXT: store i64 16
long s3 = sizeof *p1->p2;
// LLVM-NEXT: store i64 16
long s4 = sizeof *p1->p2->p2;
}
// CHECK-LABEL: declsOnly
void declsOnly() {
// PRINT-NEXT: [[KW]] T *p0;
KW T *p0;
// PRINT-NEXT: [[KW]] __attribute__((may_alias)) T *p1;
KW __attribute__((may_alias)) T *p1;
// PRINT-NEXT: [[KW]] T *p2;
KW T *p2;
// PRINT-NEXT: [[KW]] __attribute__((deprecated(""))) T *p3;
// expected-warning@+2 {{'T' is deprecated}}
// expected-note@+1 2 {{'T' has been explicitly marked deprecated here}}
KW __attribute__((deprecated(""))) T *p3;
// PRINT-NEXT: [[KW]] T *p4;
KW T *p4; // expected-warning {{'T' is deprecated}}
}
// Make sure expanded printing of tag types is turned back off in other parts
// of a tag declaration. The base class list is checked above.
// CHECK-LABEL: inMembers
void inMembers() {
// PRINT-NEXT: [[KW]] T1 {
// PRINT-NEXT: int i;
// PRINT-NEXT: };
KW T1 { int i; };
// PRINT-NEXT: [[KW]] T2 {
// PRINT-NEXT: [[KW]] T1 i;
// PRINT-NEXT: };
KW T2 { KW T1 i; };
}
// CHECK-LABEL: inInit
void inInit() {
// PRINT-NEXT: [[KW]] T1 {
// PRINT-NEXT: int i;
// PRINT-NEXT: };
KW T1 { int i; };
// PRINT-NEXT: [[KW]] T2 {
// PRINT-NEXT: long i;
// PRINT-NEXT: } t2 = {sizeof([[KW]] T1)};
KW T2 { long i; } t2 = {sizeof(KW T1)};
}
#ifdef __cplusplus
// CXX-LABEL: inMemberPtr
void inMemberPtr() {
// CXX-NEXT: [[KW]] T1 {
// CXX-NEXT: int i;
// CXX-NEXT: };
KW T1 { int i; };
// CXX-NEXT: [[KW]] T2 {
// CXX-NEXT: } T1::*p;
KW T2 {} T1::*p;
}
#endif