[Attribute/Diagnostics] Print macro if definition is an attribute declaration

[leonardchan]

Summary

If an address_space attribute is defined in a macro, print the macro instead when diagnosing a warning or error for incompatible pointers with different address_spaces.

Originally started from http://lists.llvm.org/pipermail/cfe-dev/2018-August/058702.html where the original proposal was a new pragma, but instead just changing the way address_space gets printed in a diagnostic.

We now allow this for all attributes (not just address_space), and for multiple attributes declared in the same macro.

[leonardchan]

Actually, after posting this I realize I didn't handle the macro expansion very well. I'll fix this first.

[rsmith]

include/clang/AST/ASTContext.h

1428 ↗

(On Diff #162773)

There is no reason to make this specific to address space attributes. Please keep it general.

lib/AST/TypePrinter.cpp

1370 ↗

(On Diff #162773)

This is unnecessary; just print the modified type here. (The modified type by definition does not have the attribute applied to it.)

lib/Sema/SemaType.cpp

5817–5822 ↗

(On Diff #162773)

This is not the right way to find the macro.

What you should do is this: look at the source range of the attribute, and find the object-like macro expansion(s) common to both the start and end location. Search through those for the outermost macro expansion whose range is that of the attribute plus the enclosing syntax (__attribute__(( ... )) or [[ ... ]] or similar). That macro name is the name that was used to write this type, and that's the name we should preserve.

Plus, please do this all from getAttributedType itself so that it applies to all type attributes, not just address space attributes.

test/Sema/address_space_print_macro.c

3–4 ↗

(On Diff #162773)

I know this is just a test, but please avoid using reserved identifiers here. (Drop the leading _ from these macro names.)

[leonardchan]

lib/AST/TypePrinter.cpp

1370 ↗

(On Diff #162773)

When you say the modified type, do you mean just the type without it's qualifiers? I wasn't sure if removing all the qualifiers would suffice since there were also other non-address_space qualifiers that could be printed.

[rsmith]

[e-mail] for attributes-related changes.

It would be easier and more precise to track the macro corresponding to an attribute in the Parser rather than in Sema (and stash it on the ParsedAttr for consumers such as Sema that want it). That way, we still have the information about where the attribute delimiters were, and whether there were multiple attributes in the same set of delimiter brackets. Specifically, in Parser::ParseGNUAttributes, if we find that we parsed exactly one attribute, look through the source location information for the outermost macro expansion that exactly covers the token sequence in question, and that's your corresponding macro name. (Note that we don't need to check what the expansion of the macro is, nor track what attribute-like macros have been defined, to support this approach.)

Sorry for not thinking of this sooner.

lib/AST/TypePrinter.cpp

1370 ↗

(On Diff #162773)

I mean T->getModifiedType(), which tracks what the type was before the attribute was applied.

[leonardchan]

lib/AST/TypePrinter.cpp

1370 ↗

(On Diff #162773)

Oh, I understand that you meant T->getModifiedType(). This is a special case when printing the address_space since even though the attribute is applied and printed here, when we reach the qualifiers of the modified type, the address space will still be printed unless we remove it here.

I'm not sure if there's a better way to do this though.

[rsmith]

You also need to update the various other places that create AttributedTypes (eg, template instantiation, ASTImporter, deserialization) to pass in the macro name. You can try removing the default argument from ASTContext::getAttributedType to find other places that might need updating.

include/clang/AST/Type.h

4318–4323 ↗

(On Diff #163155)

Please keep this general, there's nothing address-space-specific here.

4343–4344 ↗

(On Diff #163155)

Likewise.

include/clang/Sema/ParsedAttr.h

538–542 ↗

(On Diff #163155)

Please use MacroIdentifier or MacroName in these function names; abbreviations such as II should only be used in entities with a relatively small scope, not in public member functions (here and in `AttributedType).

A documentation comment on these would also be useful.

lib/AST/TypePrinter.cpp

1370 ↗

(On Diff #162773)

If the address space qualifiers are present on the modified type, then that's a bug in the creation of the AttributedType. And indeed looking at r340765, I see we are passing the wrong type in as the modified type when creating the AttributedType. Please fix that, and then just use getModifiedType here.

lib/Parse/ParseDecl.cpp

169–170 ↗

(On Diff #163155)

This is not right: the loop below parses multiple __attribute__s and you should track each one separately...

173 ↗

(On Diff #163155)

... by grabbing the location of the __attribute__ token here.

244–252 ↗

(On Diff #163155)

You shouldn't do this if NumParsedAttrs != 1. We're only looking for a macro that exactly covers one attribute.

(Also, your computation of the number of attributes in the attribute list is not correct in the presence of late-parsed attributes.)

246–252 ↗

(On Diff #163155)

From my earlier comment: "look through the source location information for the outermost macro expansion that exactly covers the token sequence in question, and that's your corresponding macro name. (Note that we don't need to check what the expansion of the macro is, nor track what attribute-like macros have been defined, to support this approach.)"

We should not be tracking a list of attribute-like macros in the preprocessor. Doing so is unnecessary and problematic for various reasons.

[leonardchan]

@rsmith When you clarify what you mean by outermost macro expansion? Say I have the following:

#define ATTR __attribute__
#define AS(i) address_space(i)
#define AS1 ATTR((address_space(1)))
#define AS2 ATTR((AS(2)))

int cmp(AS1 char *x, AS2 char *y) {
  return x < y ? x : y;
}

AS1 char * and AS2 char * would be diagnosed for an error relating to mismatched types, but I think outermost macro expansion implies either ATTR or AS would be the identifier stored as opposed to AS1 and AS2.

Would it be simpler to instead just check:

• the starting __attribute__ token was the start of a macro expansion
• the ending right parenthesis token was the end of a macro expansion
• both start and end tokens had the same location to indicate this attribute was used in a macro

After fulfulling these, we can call Lexer::getSourceText() to get the spelling of the macro from this SourceLocation.

[leonardchan]

lib/Parse/ParseDecl.cpp

244–252 ↗

(On Diff #163155)

One of the things we would like is for this to cover more than one attribute in the attribute list since in sparse, address_space is sometimes used with noderef.

So given # define __user __attribute__((noderef, address_space(1))), __user would be saved into the ParsedAttr made for noderef and address_space.

What would be the appropriate way to track newly added attributes into the ParsedAttributes, including late-parsed attributes?

[aaron.ballman]

include/clang/AST/Type.h

4343 ↗

(On Diff #163155)

Given that this function is const, I think the returned pointer should be as well.

lib/Lex/PPDirectives.cpp

2584 ↗

(On Diff #163155)

This count is specific to GNU spellings. For instance, a C++ spelling might have 5 tokens (two square brackets, attribute-token, two more square brackets) or more and a declspec spelling might have 4 tokens (__declspec keyword, paren, attribute token, paren).

2586–2588 ↗

(On Diff #163155)

Why does this need to be specific to GNU-style spellings?

2720–2721 ↗

(On Diff #163155)

This should not be specific to address_space, but even if it were, this is wrong as it can be spelled [[clang::address_space(0)]].

lib/Parse/ParseDecl.cpp

116 ↗

(On Diff #163155)

attrs doesn't meet the usual naming conventions. Same with i below.

119 ↗

(On Diff #163155)

You can use a range-based for loop here instead.

[leonardchan]

• Removed default value for getAttributedType and added any macro identifier necessary as a fourth argument to getAttributedType
• Added tracking for LateAttrs to keep any found macro identifier, although I don't quite know how I can test this in the same fashion that I test with address_space since it doesn't get printed in the type.

lib/AST/TypePrinter.cpp

1370 ↗

(On Diff #162773)

Making another patch for this.

lib/Lex/PPDirectives.cpp

2586–2588 ↗

(On Diff #163155)

Similar to the noderef patch I sent out, this is initially only meant for GNU-style attributes but can be expanded on later.

The main goal for our side was to change the diagnostics relating to address_spaces to instead print the macro if the attribute was defined in a macro. This was initially discussed in http://lists.llvm.org/pipermail/cfe-dev/2018-August/058702.html, but eventually decided on not using a pragma and instead redirecting diagnostics (http://lists.llvm.org/pipermail/cfe-dev/2018-August/058732.html).

Essentially, this was meant specifically for just the address_space attribute, which I believe only has GNU-style support, but Richard Smith thought that this would be useful to apply to other attributes. For our use case alone, we just need it to work for GNU-style, but we can expand on this afterwards for other attribute spellings.

[leonardchan]

lib/Lex/PPDirectives.cpp

2584 ↗

(On Diff #163155)

See comment below

2720–2721 ↗

(On Diff #163155)

Removed code relating to the processor since we don't need it anymore

lib/Parse/ParseDecl.cpp

116 ↗

(On Diff #163155)

Removed

119 ↗

(On Diff #163155)

The condition should instead be i < attrs.size(), sorry.

I don't know if ParsedAttributesView has a reverse iterator though or I can start with an iterator in the middle of the view.

246–252 ↗

(On Diff #163155)

Removed the preprocessor code

[rsmith]

I think this patch is nearly ready to commit. However... if you want to handle macros that specify a sequence of attributes, we should switch to treating the macro name as a separate type sugar node rather than modeling it as a name for the AttributedType node. Up to you how we proceed from here -- if you want to land this patch with a one-attribute-in-the-macro restriction, that seems fine; if you'd prefer to go straight to a more general approach where we add a new type sugar representation for a single macro describing (potentially) multiple attributes, that's fine too.

lib/AST/ASTDiagnostic.cpp

78 ↗

(On Diff #163604)

Use castAs here and below (because it would be a programming error if the type isn't an AttributedType).

lib/AST/ASTImporter.cpp

991 ↗

(On Diff #163604)

You need to import the identifier; the source and destination ASTs have different identifier tables. (Importer.Import(T->getMacroIdentifier())).

lib/AST/TypePrinter.cpp

1370 ↗

(On Diff #162773)

Incidentally, the last two arguments to the AddressSpaceAttr constructor in that patch (address space and spelling list index) are also reversed.

lib/Parse/ParseDecl.cpp

138 ↗

(On Diff #163604)

No need to copy the entire Token here, you only use its location before. It's also idiomatic to fold this into consuming the token:

SourceLocation AttrTokLoc = ConsumeToken();

215–220 ↗

(On Diff #163604)

You're only looking at the innermost macro expansion; I still think we should take the outermost one. (You can iteratively walk the expansion locations of the start and end locations (SourceManager::getExpansionLocStart/End) to build a list of FileIDs representing macro expansions that each of them is included in, and then take the last common such FileID that represents an object-like macro. You can use SourceManager::getSLocEntry to get the corresponding ExpansionInfo for the macro, isFunctionMacroExpansion to determine if it's a function-like or object-like macro, and once you know it's object-like, take the spelling locations of the ExpansionLocStart and ExpansionLocEnd to find the name of the macro.

244–252 ↗

(On Diff #163155)

One of the things we would like is for this to cover more than one attribute in the attribute list since in sparse, address_space is sometimes used with noderef.

Hold on, this is a new requirement compared to what we'd previously discussed (giving a name to an address space). How important is this use case to you?

I don't think it's a reasonable AST model to assign a macro identifier to an AttributedType if the macro defines multiple attributes. If you really want to handle that use case, I think that an identifier on the AttributedType is the wrong way to model it, and we should instead be creating a new type sugar node representing a type decoration written as a macro.

Assuming you want to go ahead with the current patch direction (at least in the short term), please add the "only one attribute in the macro" check.

[mcgrathr]

lib/Parse/ParseDecl.cpp

244–252 ↗

(On Diff #163155)

A single macro that uses multiple attributes is the central use case for us.
It would be fine if it's constrained to a single attribute clause (or [[...]] clause) with the attributes comma-separated, as in attribute((foo, bar)) as opposed to two separate attribute((foo)) attribute((bar)) in the macro, if that matters. It's even fine if it's constrained to the macro being nothing but the attribute((foo, bar)) clause (aside from whitespace and comments).

Leo can decide how he wants to proceed as far as incremental implementation.
But we won't have a real-world use for the feature only covering a single attribute.
We'll start using when it can cover the cases like the Linux user and iomem examples (address_space + noderef).

[leonardchan]

@rsmith So I chose to go with the type sugar route since we would prefer to have multiple attributes in one attribute list. This type just contains the underlying type and the macro identifier originally held by the AttributedType. Do you have any recommendations on where this type should be created?

Currently, I'm wrapping any AttributedType created under processTypeAttrs with this type since I still only hold the macro identifier in the ParsedAttr. The problem is that I keep incrementally running into failing assertions that I can slowly address, but all these assertions make me think I'm approaching this the wrong way. The failing assertions come from building or finding the type location if this type.

I'm thinking I could either make this type a subclass of AttributedType since we will essentially be using this only for attributes declared in a macro (I think this would allow me to not have to change some of the stuff that happens under GetTypeSourceInfoForDeclarator), or somehow find a way to make this in another part of Sema, although I would still need access to the parsed attributes so I would know what the macro identifiers are.

[rsmith]

In D51329#1229061, @leonardchan wrote:

@rsmith So I chose to go with the type sugar route since we would prefer to have multiple attributes in one attribute list. This type just contains the underlying type and the macro identifier originally held by the AttributedType. Do you have any recommendations on where this type should be created?

I think the most natural thing to do would be to create the sugar node in processTypeAttrs after parsing each "chunk" of attributes produced by the same macro. (You'll need to extend ParsedAttributesView so it can tell you which ranges came from which macros.)

I'm thinking I could either make this type a subclass of AttributedType since we will essentially be using this only for attributes declared in a macro (I think this would allow me to not have to change some of the stuff that happens under GetTypeSourceInfoForDeclarator), or somehow find a way to make this in another part of Sema, although I would still need access to the parsed attributes so I would know what the macro identifiers are.

Your new type sugar node should be a new subclass of Type unrelated to AttributedType, maybe MacroQualifiedType. You'll need to teach TypeSpecLocFiller to fill in location information from it, but you can save that into the ParsedAttributesView when you parse the attributes and identify the macro expansions therein.

[leonardchan]

• Added a new type sugar node MacroDefinedType which wraps AttributedTypes for the purpose of determining if an attribute was defined in a macro (this took much longer than I would've expected it to).

[leonardchan]

lib/Sema/SemaType.cpp

5817–5822 ↗

(On Diff #162773)

Moved the saved identifier into the new type sugar.

[leonardchan]

clang/lib/AST/TypePrinter.cpp

973–979

This has not been addressed yet in this patch, but will still make another patch moving the address_space from the qualifier to the AttributedType (in reference to r340765).

[leonardchan]

• Rebase after D55447

[leonardchan]

clang/lib/AST/TypePrinter.cpp

973–979

@rsmith Finally fixed in D55447, so I don't think there are any more outstanding prior comments that haven't been addressed in this patch so far.

[rsmith]

clang/include/clang/AST/Type.h

4188

This represents a macro qualifier, not a type defined in a macro, so I don't think this name is appropriate. Maybe MacroQualifiedType?

4204

Please also provide an accessor to get the unqualified type here (that is, the type that we would have had if the macro had not been written -- the original type of the AttributedType). Right now, that's (effectively) being computed in the type printer, which doesn't seem like the right place for that logic.

clang/lib/AST/Type.cpp

383–387

This doesn't seem like a sufficiently general operation to warrant being a member of QualType to me, and like IgnoreParens before it, this is wrong with regard to qualifiers (it drops top-level qualifiers on the type if they're outside the macro qualifier). Looking through the uses below, I think there are better ways to write them that avoid the need for this function.

clang/lib/AST/TypePrinter.cpp

969–970

This should apply to all attributes, not only address space attributes.

975–979

This is the code that I mentioned above that should be moved to MacroDefinedType.

clang/lib/Parse/ParseDecl.cpp

317

Typo "attatch"

322–327

I think these checks need to be moved to the last loop of FindLocsWithCommonFileID. Otherwise for a case like:

#define THING \
  int *p = nullptr;
  AS1 int *q = nullptr;

THING

... FindLocsWithCommonFileID will pick out the THING macro and return the range from the int token to the second semicolon, and the checks here will fail. Instead, we should pick out the inner AS1 expansion, because it's the outermost macro expansion that starts with StartLoc and ends with EndLoc.

clang/lib/Sema/SemaExpr.cpp

13701

Please change TypeLoc::getAsAdjusted to skip macro type sugar instead of skipping it here. (getAsAdjusted already skips AttributedType sugar, and your new sugar node is the same kind of thing.)

Please also change Type::getAsAdjusted to likewise remove the new type node.

clang/lib/Sema/SemaStmt.cpp

3384–3388

This duplicates the logic in TypeLoc::getAsAdjusted (and misses a case!). This whole function definition should be replaced by return FD->getTypeSourceInfo()->getTypeLoc().getAsAdjusted<FunctionProtoTypeLoc>().getReturnLoc();.

clang/lib/Sema/SemaType.cpp

6989–7000

Instead of calling IgnoreParens() and IgnoreMacroDefinitions here, I think we should just be ignoring any type sugar by using getAs<AttributedType>():

bool Sema::hasExplicitCallingConv(QualType T) {
  while (const auto *AT = T->getAs<AttributedType>()) {
    if (AT->isCallingConv())
      return true;
    T = AT->getModifiedType();
  }
  return false;
}

(Note also the change from passing T by reference -- and then never storing to it in the function -- to passing it by value.)

7583–7590

The handling (both here and in the parser) for a macro that defines multiple attributes doesn't seem right. Given:

#define ATTRS __attribute__((attr1, attr2))
ATTRS int x;

it looks like you'll end up with a type built as

AttributedType attr1
 `- MacroDefinedType
      `- AttributedType attr2
          `- int

... which seems wrong.

The parser representation also can't distinguish between the above case and

#define ATTRS __attribute__((attr1))
ATTRS
#define ATTRS __attribute__((attr2))
ATTRS
int x;

... since both will be represented as simply a macro identifier ATTR attached to two different attributes (you could solve this by tracking the source location of the expansion loc of the macro in the parsed attribute representation, instead of or in addition to the macro identifier).

And the AST representation can't distinguish between the above and

#define ATTRS __attribute__((attr1))
ATTRS __attribute__((attr2)) int x;

... because it doesn't track what the modified type was, so we have to guess which attributes are covered by the macro.

Perhaps the best thing would be to support only the case of a macro that expands to exactly one attribute for the initial commit, and add support for macros covering multiple attributes as a follow-up commit?

clang/test/Frontend/macro_defined_type.cpp

10

Typo 'wether'

[leonardchan]

clang/lib/AST/Type.cpp

383–387

Removed this method.

clang/lib/Parse/ParseDecl.cpp

322–327

Moved, although this doesn't appear to fix this case. On closer inspection, when generating the vector of starting locations, the expansion location for AS1 doesn't seem to be returned by getExpansionLocStart. It goes straight from the location of the __attribute__ behind AS1 to THING and skips AS1. I found this out by just dumping StartLoc on every iteration.

The only way I can generate the location for AS1 in THING is by also watching for the spelling location of each expansion, but this SourceLoc is not a macro ID and would not fulfill these last 2 checks. Is this intended? If it's a bug I don't mind addressing it if you point me in the right direction to start.

clang/lib/Sema/SemaType.cpp

6989–7000

When using only getAs, the following 3 tests fail:

Clang :: CodeGenCXX/mangle-ms.cpp
Clang :: SemaCXX/calling-conv-compat.cpp
Clang :: SemaCXX/decl-microsoft-call-conv.cpp

since using getAs would involved removing a TypeDefType for each of these. Looking at the comment above this method's declaration, part of the intent is to retain the typedef sugar. We could still use getAs and not IgnoreMacroDefinitions by additionally checking for a typedef:

const AttributedType *AT;
while ((AT = T->getAs<AttributedType>()) && !isa<TypedefType>(T)) {

Using !T->getAs<TypedefType>() will still fail for types laid out as:

AttributedType
` - TypedefType

7583–7590

If it makes this cleaner and easier to review, I don't mind separating it into 2 patches with the first working for exactly one and the followup for multiple. For us though, we would mainly be using this for multiple attribute macros (especially __attribute__((address_space(n), noderef)). I can split it into 2 if you would like after this revision.

As for the cases you presented, for

#define ATTRS __attribute__((attr1, attr2))
ATTRS int x;

I see that this prevents from adding any more MacroQualifiedTypes for attributes that share the same name. Updated in this revision so that we continue to wrap AttributedTypes, producing:

MacroQualifiedType (ATTRS)
 `- AttributedType attr1
     ` - MacroQualifiedType (ATTRS)
        `- AttributedType attr2
             `- int

In the case of

#define ATTRS __attribute__((attr1))
ATTRS
#define ATTRS __attribute__((attr2))
ATTRS
int x;

I added the expansion loc so we can distinguish between this and the first case now.

As for

#define ATTRS __attribute__((attr1))
ATTRS __attribute__((attr2)) int x;

With this new revision, the AST representation now differs from the previous 2 examples in that only attr1 gets wrapped with a MacroQualifiedType and not attr2 producing:

AttributedType attr2
 ` - MacroQualifiedType (ATTRS)
    `- AttributedType attr1
         `- int

I also added test cases for these.

[rsmith]

clang/include/clang/AST/Type.h

4187

This comment is out of date. "[...] a type that was qualified by a qualifier written as a macro invocation" maybe?

4196

Types should not carry source locations. If you want location information, it should be stored on the TypeLoc instead.

4212–4214

getUnqualifiedType means something very specific in Clang, and this isn't it. getModifiedType would be a better name.

clang/include/clang/AST/TypeLoc.h

1086

This struct is where the ExpansionLoc should live.

clang/lib/AST/TypePrinter.cpp

107–108

I think this is more expensive than we need and unnecessary... see below.

979

Instead of recursing to the modified type here, and using a separate set to prevent printing the same macro twice, how about something like:

// Step over MacroQualifiedTypes from the same macro to find the type ultimately
// qualified by the macro qualifier.
QualType Inner = T->getModifiedType();
while (auto *InnerMQT = dyn_cast<MacroQualifiedType>(Inner)) {
  if (InnerMQT->getMacroIdentifier() != T->getMacroIdentifier())
    break;
  Inner = InnerMQT->getModifiedType();
}
printBefore(Inner, OS);

(and likewise in printAfter). And perhaps the above loop should be in MacroQualifiedType::getModifiedType() rather than here.

clang/lib/Parse/ParseDecl.cpp

322–327

Right, sorry, mistake on my part. To deal with this, you need to call isAt{Start,End}OfMacroExpansion while collecting StartLocs and EndLocs, and stop once you hit a location where they return false. (That would mean that you never step from the location of AS1 out to the location of THING.)

clang/lib/Sema/SemaType.cpp

6989–7000

Can you give an example of the failures? The approach you're using here isn't quite right, as it will skip over a typedef that's wrapped in another type sugar node (when T is not a typedef but desugars to one). Something like && AT->getAs<TypedefType>() == T->getAs<TypedefType>() (that is: if we'd be stripping off a typedef sugar node to reach the AttributedType, then stop) should work, but maybe there's a better way to express that.

7404

(Unused, please remove.)

7583–7590

I think the ideal representation for this case would be

MacroQualifiedType (ATTRS)
 `- AttributedType attr1
      `- AttributedType attr2
           `- int

... but I can see that'll be a pain to produce. Let's go with your current representation for now and look into improving it as a follow-up change. (This'll give weird behavior in some cases: removing the outer AttributedType will still lead to a type that pretty-prints as ATTRS int, whereas it should pretty-print as __attribute__((attr2)) int because attr1 is not applied to the type.)

clang/lib/Sema/TreeTransform.h

6218

(Copy the expansion loc here.)

clang/lib/Serialization/ASTReader.cpp

6203

The name of this enumerator is out of date; should be TYPE_MACRO_QUALIFIED

clang/test/SemaObjC/gc-attributes.m

12–21

This is wrong: we need to print the macro qualifier on the right in cases like this so that it attaches to the pointer. You can use TypePrinter::canPrefixQualifier to determine whether to print the macro name on the left or the right.

[leonardchan]

clang/lib/Parse/ParseDecl.cpp

322–327

Hmm. So I still run into the problem of none of the locations being at the start or end of the macro expansion. In your example, I only find 2 source locations at all. Let's say I have:

1 #define AS1 __attribute__((address_space(1)))
2
3 int main() {
4 #define THING \
5   int *p = 0; \
6   AS1 int *q = p;
7
8   THING;
9 }

I only see the following expansion source locations:

/usr/local/google/home/leonardchan/misc/test.c:8:3 <Spelling=/usr/local/google/home/leonardchan/misc/test.c:1:13>
/usr/local/google/home/leonardchan/misc/test.c:8:3 <Spelling=/usr/local/google/home/leonardchan/misc/test.c:6:3>

And it seems none of them return true for isAtStartOfMacroExpansion since the __attribute__ keyword isn't the first token of THING. I imagine stopping early would work if the 2nd expansion location instead referred to AS1 (on line 6 col 3), but it doesn't seem to be the case here.

I can also see similar results for other examples where the macro is nested but does not encapsulate the whole macro:

#define THING2 int AS1 *q2 = p2;
int *p2;
THING2;  // Error doesn't print AS1

For our case, it seems like the correct thing to do is to get the spelling location and default to it if the macro itself doesn't contain the whole attribute. I updated and renamed this function to account for this and we can now see AS1 printed. Also added test cases for this.

For cases like #define AS2 AS1, AS1 is still printed, but this is intended since AS1 is more immediate of an expansion than AS2.

clang/lib/Sema/SemaType.cpp

6989–7000

Updated.

Also there's just 1 error from each. This can be replicated just by using the new function and omitting the typedef check.

CodeGenCXX/mangle-ms.cpp

/usr/local/google/home/leonardchan/llvm-monorepo/llvm-project-2/clang/test/CodeGenCXX/mangle-ms.cpp:386:15: error: CHECK-DAG: expected string not found in input
// CHECK-DAG: ??2TypedefNewDelete@@SAPAXI@Z

SemaCXX/calling-conv-compat.cpp

error: 'error' diagnostics seen but not expected: 
  File /usr/local/google/home/leonardchan/llvm-monorepo/llvm-project-2/clang/test/SemaCXX/calling-conv-compat.cpp Line 367: cannot initialize a variable of type 'MemberPointers::fun_cdecl MemberPointers::A::*' with an rvalue of type 'void (MemberPointers::A::*)() __attribute__((thiscall))'

SemaCXX/decl-microsoft-call-conv.cpp

error: 'error' diagnostics expected but not seen: 
  File /usr/local/google/home/leonardchan/llvm-monorepo/llvm-project-2/clang/test/SemaCXX/decl-microsoft-call-conv.cpp Line 88: function declared 'cdecl' here was previously declared without calling convention

7583–7590

Will do.

clang/test/SemaObjC/gc-attributes.m

12–21

Fixed. I forgot to add a check for ObjCGCAttrs when creating the type.

[rsmith]

clang/lib/Parse/ParseDecl.cpp

322–327

I'd like to get some (correct) form of this landed, so I wonder if we can do something much simpler for now. Can we just check that the first token of the attribute-specifier isAtStartOfMacroExpansion and the last token isAtEndOfMacroExpansion and that they're from the same expansion of the same (object-like) macro? That won't find the outermost such macro, nor will it deal with cases where __attribute__ or the last ) was itself generated by a macro, but it should not have any false positives.

[leonardchan]

clang/lib/Parse/ParseDecl.cpp

322–327

No problem. Done, and our original test cases still pass.

[leonardchan]

*ping*

[rsmith]

Thanks, looks great!

I think the handling of the expansion location in the MacroQualifiedTypeLoc isn't quite right yet (it looks like it will never actually be set at all, because the code to set it is not reachable) but it's also unused at the moment, so I'm happy with that being fixed as a follow-up change after you land this.

clang/lib/Sema/SemaType.cpp

5647

This should use getMacroExpansionLoc on the relevant attribute (you can store the location information in TypeProcessingState and retrieve it from here; see what we do for AttributedType for example).

I think we'll also need a VisitMacroQualifiedTypeLoc override on TypeSpecLocFiller for attributes in the decl-specifiers rather than attributes on declarator chunks. (See below.)

5727–5728

Skipping MacroQualifiedTypeLocs here means you're never reaching the above DeclaratorLocFiller::VisitMacroQualifiedTypeLoc.

[leonardchan]

In D51329#1488465, @rsmith wrote:

Thanks, looks great!

I think the handling of the expansion location in the MacroQualifiedTypeLoc isn't quite right yet (it looks like it will never actually be set at all, because the code to set it is not reachable) but it's also unused at the moment, so I'm happy with that being fixed as a follow-up change after you land this.

Thanks! Will make another patch eventually with the followup changes.

[JDevlieghere]

I think this is change is causing an assertion to be hit:

http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/25103/consoleFull#-239233992d489585b-5106-414a-ac11-3ff90657619c
http://green.lab.llvm.org/green/job/clang-stage1-configure-RA/56122/console

Can you have a look?

[leonardchan]

In D51329#1488918, @JDevlieghere wrote:

I think this is change is causing an assertion to be hit:

http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/25103/consoleFull#-239233992d489585b-5106-414a-ac11-3ff90657619c
http://green.lab.llvm.org/green/job/clang-stage1-configure-RA/56122/console

Can you have a look?

I've noticed it. Still looking at it. I'll revert this if I don't figure out what's causing it by the end of the night.

[miyuki]

This caused https://bugs.llvm.org/show_bug.cgi?id=41835
Could you please look into it?

[leonardchan]

In D51329#1498193, @miyuki wrote:

This caused https://bugs.llvm.org/show_bug.cgi?id=41835
Could you please look into it?

Sorry for the delay. I submitted r360448 as a fix for this.

[mstorsjo]

This caused a regression when including mingw-w64 headers (in a case where they happen to include redundant/duplicate attribute specifications), triggering asserts. See https://bugs.llvm.org/show_bug.cgi?id=41852 for details.

[leonardchan]

In D51329#1499307, @mstorsjo wrote:

This caused a regression when including mingw-w64 headers (in a case where they happen to include redundant/duplicate attribute specifications), triggering asserts. See https://bugs.llvm.org/show_bug.cgi?id=41852 for details.

Thanks for the alert. I submitted r360544 which should address this.

clang/include/clang/AST/ASTContext.h

public:
 
   TypeSourceInfo *
   getTemplateSpecializationTypeInfo(TemplateName T, SourceLocation TLoc,
                                     const TemplateArgumentListInfo &Args,
                                     QualType Canon = QualType()) const;
 
   QualType getParenType(QualType NamedType) const;
 
+  QualType getMacroQualifiedType(QualType UnderlyingTy,
+                                 const IdentifierInfo *MacroII) const;
+
   QualType getElaboratedType(ElaboratedTypeKeyword Keyword,
                              NestedNameSpecifier *NNS, QualType NamedType,
                              TagDecl *OwnedTagDecl = nullptr) const;
   QualType getDependentNameType(ElaboratedTypeKeyword Keyword,
                                 NestedNameSpecifier *NNS,
                                 const IdentifierInfo *Name,
                                 QualType Canon = QualType()) const;
 

clang/include/clang/AST/RecursiveASTVisitor.h

 
 DEF_TRAVERSE_TYPE(InjectedClassNameType, {})
 
 DEF_TRAVERSE_TYPE(AttributedType,
                   { TRY_TO(TraverseType(T->getModifiedType())); })
 
 DEF_TRAVERSE_TYPE(ParenType, { TRY_TO(TraverseType(T->getInnerType())); })
 
+DEF_TRAVERSE_TYPE(MacroQualifiedType,
+                  { TRY_TO(TraverseType(T->getUnderlyingType())); })
+
 DEF_TRAVERSE_TYPE(ElaboratedType, {
   if (T->getQualifier()) {
     TRY_TO(TraverseNestedNameSpecifier(T->getQualifier()));
   }
   TRY_TO(TraverseType(T->getNamedType()));
 })
 
 DEF_TRAVERSE_TYPE(DependentNameType,
for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
     TRY_TO(TraverseTemplateArgumentLoc(TL.getArgLoc(I)));
   }
 })
 
 DEF_TRAVERSE_TYPELOC(InjectedClassNameType, {})
 
 DEF_TRAVERSE_TYPELOC(ParenType, { TRY_TO(TraverseTypeLoc(TL.getInnerLoc())); })
 
+DEF_TRAVERSE_TYPELOC(MacroQualifiedType,
+                     { TRY_TO(TraverseTypeLoc(TL.getInnerLoc())); })
+
 DEF_TRAVERSE_TYPELOC(AttributedType,
                      { TRY_TO(TraverseTypeLoc(TL.getModifiedLoc())); })
 
 DEF_TRAVERSE_TYPELOC(ElaboratedType, {
   if (TL.getQualifierLoc()) {
     TRY_TO(TraverseNestedNameSpecifierLoc(TL.getQualifierLoc()));
   }
   TRY_TO(TraverseTypeLoc(TL.getNamedTypeLoc()));

clang/include/clang/AST/Type.h

public:
   TypedefNameDecl *getDecl() const { return Decl; }
 
   bool isSugared() const { return true; }
   QualType desugar() const;
 
   static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
 };
 
+/// Sugar type that represents a type that was qualified by a qualifier written
+/// as a macro invocation.
+class MacroQualifiedType : public Type {
+  friend class ASTContext; // ASTContext creates these.
+
+  QualType UnderlyingTy;
+  const IdentifierInfo *MacroII;
+
+  MacroQualifiedType(QualType UnderlyingTy, QualType CanonTy,
+                     const IdentifierInfo *MacroII)
+      : Type(MacroQualified, CanonTy, UnderlyingTy->isDependentType(),
+             UnderlyingTy->isInstantiationDependentType(),
+             UnderlyingTy->isVariablyModifiedType(),
+             UnderlyingTy->containsUnexpandedParameterPack()),
+        UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
+    assert(isa<AttributedType>(UnderlyingTy) &&
+           "Expected a macro qualified type to only wrap attributed types.");
+  }
+
+public:
+  const IdentifierInfo *getMacroIdentifier() const { return MacroII; }
+  QualType getUnderlyingType() const { return UnderlyingTy; }
+
+  /// Return this attributed type's modified type with no qualifiers attached to
+  /// it.
+  QualType getModifiedType() const;
+
+  bool isSugared() const { return true; }
+  QualType desugar() const;
+
+  static bool classof(const Type *T) {
+    return T->getTypeClass() == MacroQualified;
+  }
+};
+
 /// Represents a `typeof` (or __typeof__) expression (a GCC extension).
 class TypeOfExprType : public Type {
   Expr *TOExpr;
 
 protected:
   friend class ASTContext; // ASTContext creates these.
 
   TypeOfExprType(Expr *E, QualType can = QualType());
while (Ty) {
     if (const auto *A = dyn_cast<AttributedType>(Ty))
       Ty = A->getModifiedType().getTypePtr();
     else if (const auto *E = dyn_cast<ElaboratedType>(Ty))
       Ty = E->desugar().getTypePtr();
     else if (const auto *P = dyn_cast<ParenType>(Ty))
       Ty = P->desugar().getTypePtr();
     else if (const auto *A = dyn_cast<AdjustedType>(Ty))
       Ty = A->desugar().getTypePtr();
+    else if (const auto *M = dyn_cast<MacroQualifiedType>(Ty))
+      Ty = M->desugar().getTypePtr();
     else
       break;
   }
 
   // Just because the canonical type is correct does not mean we can use cast<>,
   // since we may not have stripped off all the sugar down to the base type.
   return dyn_cast<T>(Ty);
 }

clang/include/clang/AST/TypeLoc.h

TypeLoc getNextTypeLoc() const {
     return getNextTypeLocImpl(*this);
   }
 
   /// Skips past any qualifiers, if this is qualified.
   UnqualTypeLoc getUnqualifiedLoc() const; // implemented in this header
 
   TypeLoc IgnoreParens() const;
 
+  /// Strips MacroDefinitionTypeLocs from a type location.
+  TypeLoc IgnoreMacroDefinitions() const;
+
   /// Find a type with the location of an explicit type qualifier.
   ///
   /// The result, if non-null, will be one of:
   ///   QualifiedTypeLoc
   ///   AtomicTypeLoc
   ///   AttributedTypeLoc, for those type attributes that behave as qualifiers
   TypeLoc findExplicitQualifierLoc() const;
 
public:
   }
 
   void initializeLocal(ASTContext &Context, SourceLocation Loc) {
     setNameLoc(Loc);
     setNameEndLoc(Loc);
   }
 };
 
+struct MacroQualifiedLocInfo {
+  SourceLocation ExpansionLoc;
+};
+
+class MacroQualifiedTypeLoc
+    : public ConcreteTypeLoc<UnqualTypeLoc, MacroQualifiedTypeLoc,
+                             MacroQualifiedType, MacroQualifiedLocInfo> {
+public:
+  void initializeLocal(ASTContext &Context, SourceLocation Loc) {
+    setExpansionLoc(Loc);
+  }
+
+  TypeLoc getInnerLoc() const { return getInnerTypeLoc(); }
+
+  const IdentifierInfo *getMacroIdentifier() const {
+    return getTypePtr()->getMacroIdentifier();
+  }
+
+  SourceLocation getExpansionLoc() const {
+    return this->getLocalData()->ExpansionLoc;
+  }
+
+  void setExpansionLoc(SourceLocation Loc) {
+    this->getLocalData()->ExpansionLoc = Loc;
+  }
+
+  QualType getInnerType() const { return getTypePtr()->getUnderlyingType(); }
+
+  SourceRange getLocalSourceRange() const {
+    return getInnerLoc().getLocalSourceRange();
+  }
+};
+
 struct ParenLocInfo {
   SourceLocation LParenLoc;
   SourceLocation RParenLoc;
 };
 
 class ParenTypeLoc
   : public ConcreteTypeLoc<UnqualTypeLoc, ParenTypeLoc, ParenType,
                            ParenLocInfo> {
while (!T::isKind(Cur)) {
     if (auto PTL = Cur.getAs<ParenTypeLoc>())
       Cur = PTL.getInnerLoc();
     else if (auto ATL = Cur.getAs<AttributedTypeLoc>())
       Cur = ATL.getModifiedLoc();
     else if (auto ETL = Cur.getAs<ElaboratedTypeLoc>())
       Cur = ETL.getNamedTypeLoc();
     else if (auto ATL = Cur.getAs<AdjustedTypeLoc>())
       Cur = ATL.getOriginalLoc();
+    else if (auto MQL = Cur.getAs<MacroQualifiedTypeLoc>())
+      Cur = MQL.getInnerLoc();
     else
       break;
   }
   return Cur.getAs<T>();
 }
 
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_TYPELOC_H

clang/include/clang/AST/TypeNodes.def

 DEPENDENT_TYPE(DependentVector, Type)
 TYPE(ExtVector, VectorType)
 ABSTRACT_TYPE(Function, Type)
 TYPE(FunctionProto, FunctionType)
 TYPE(FunctionNoProto, FunctionType)
 DEPENDENT_TYPE(UnresolvedUsing, Type)
 NON_CANONICAL_TYPE(Paren, Type)
 NON_CANONICAL_TYPE(Typedef, Type)
+NON_CANONICAL_TYPE(MacroQualified, Type)
 NON_CANONICAL_TYPE(Adjusted, Type)
 NON_CANONICAL_TYPE(Decayed, AdjustedType)
 NON_CANONICAL_UNLESS_DEPENDENT_TYPE(TypeOfExpr, Type)
 NON_CANONICAL_UNLESS_DEPENDENT_TYPE(TypeOf, Type)
 NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Decltype, Type)
 NON_CANONICAL_UNLESS_DEPENDENT_TYPE(UnaryTransform, Type)
 ABSTRACT_TYPE(Tag, Type)
 TYPE(Record, TagType)

clang/include/clang/Parse/Parser.h

private:
   /// end of the class declaration after parsing all other member
   /// member declarations.
   /// FIXME: Perhaps we should change the name of LateParsedDeclaration to
   /// LateParsedTokens.
   struct LateParsedAttribute : public LateParsedDeclaration {
     Parser *Self;
     CachedTokens Toks;
     IdentifierInfo &AttrName;
+    IdentifierInfo *MacroII = nullptr;
     SourceLocation AttrNameLoc;
     SmallVector<Decl*, 2> Decls;
 
     explicit LateParsedAttribute(Parser *P, IdentifierInfo &Name,
                                  SourceLocation Loc)
       : Self(P), AttrName(Name), AttrNameLoc(Loc) {}
 
     void ParseLexedAttributes() override;

clang/include/clang/Sema/ParsedAttr.h

enum Syntax {
     // without adding related code to TableGen/ClangAttrEmitter.cpp.
     /// Context-sensitive version of a keyword attribute.
     AS_ContextSensitiveKeyword,
   };
 
 private:
   IdentifierInfo *AttrName;
   IdentifierInfo *ScopeName;
+  IdentifierInfo *MacroII = nullptr;
+  SourceLocation MacroExpansionLoc;
   SourceRange AttrRange;
   SourceLocation ScopeLoc;
   SourceLocation EllipsisLoc;
 
   unsigned AttrKind : 16;
 
   /// The number of expression arguments this attribute has.
   /// The expressions themselves are stored after the object.
public:
   }
 
   IdentifierInfo *getPropertyDataSetter() const {
     assert(isDeclspecPropertyAttribute() &&
            "Not a __delcspec(property) attribute");
     return getPropertyDataBuffer().SetterId;
   }
 
+  /// Set the macro identifier info object that this parsed attribute was
+  /// declared in if it was declared in a macro. Also set the expansion location
+  /// of the macro.
+  void setMacroIdentifier(IdentifierInfo *MacroName, SourceLocation Loc) {
+    MacroII = MacroName;
+    MacroExpansionLoc = Loc;
+  }
+
+  /// Returns true if this attribute was declared in a macro.
+  bool hasMacroIdentifier() const { return MacroII != nullptr; }
+
+  /// Return the macro identifier if this attribute was declared in a macro.
+  /// nullptr is returned if it was not declared in a macro.
+  IdentifierInfo *getMacroIdentifier() const { return MacroII; }
+
+  SourceLocation getMacroExpansionLoc() const {
+    assert(hasMacroIdentifier() && "Can only get the macro expansion location "
+                                   "if this attribute has a macro identifier.");
+    return MacroExpansionLoc;
+  }
+
   /// Get an index into the attribute spelling list
   /// defined in Attr.td. This index is used by an attribute
   /// to pretty print itself.
   unsigned getAttributeSpellingListIndex() const;
 
   bool isTargetSpecificAttr() const;
   bool isTypeAttr() const;
   bool isStmtAttr() const;

clang/include/clang/Sema/Sema.h

public:
   /// wasn't specified explicitly.  This handles method types formed from
   /// function type typedefs and typename template arguments.
   void adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor,
                               SourceLocation Loc);
 
   // Check if there is an explicit attribute, but only look through parens.
   // The intent is to look for an attribute on the current declarator, but not
   // one that came from a typedef.
-  bool hasExplicitCallingConv(QualType &T);
+  bool hasExplicitCallingConv(QualType T);
 
   /// Get the outermost AttributedType node that sets a calling convention.
   /// Valid types should not have multiple attributes with different CCs.
   const AttributedType *getCallingConvAttributedType(QualType T) const;
 
   /// Stmt attributes - this routine is the top level dispatcher.
   StmtResult ProcessStmtAttributes(Stmt *Stmt,
                                    const ParsedAttributesView &Attrs,

clang/include/clang/Serialization/ASTBitCodes.h

enum TypeCode {
 
       /// A DependentSizedExtVectorType record.
       TYPE_DEPENDENT_SIZED_EXT_VECTOR = 46,
 
       /// A DependentAddressSpaceType record.
       TYPE_DEPENDENT_ADDRESS_SPACE = 47,
 
       /// A dependentSizedVectorType record.
-      TYPE_DEPENDENT_SIZED_VECTOR = 48
+      TYPE_DEPENDENT_SIZED_VECTOR = 48,
+
+      /// A type defined in a macro.
+      TYPE_MACRO_QUALIFIED = 49
     };
 
     /// The type IDs for special types constructed by semantic
     /// analysis.
     ///
     /// The constants in this enumeration are indices into the
     /// SPECIAL_TYPES record.
     enum SpecialTypeIDs {

clang/lib/ARCMigrate/TransGCAttrs.cpp

void lookForAttribute(Decl *D, TypeSourceInfo *TInfo) {
     TypeLoc TL = TInfo->getTypeLoc();
     while (TL) {
       if (QualifiedTypeLoc QL = TL.getAs<QualifiedTypeLoc>()) {
         TL = QL.getUnqualifiedLoc();
       } else if (AttributedTypeLoc Attr = TL.getAs<AttributedTypeLoc>()) {
         if (handleAttr(Attr, D))
           break;
         TL = Attr.getModifiedLoc();
+      } else if (MacroQualifiedTypeLoc MDTL =
+                     TL.getAs<MacroQualifiedTypeLoc>()) {
+        TL = MDTL.getInnerLoc();
       } else if (ArrayTypeLoc Arr = TL.getAs<ArrayTypeLoc>()) {
         TL = Arr.getElementLoc();
       } else if (PointerTypeLoc PT = TL.getAs<PointerTypeLoc>()) {
         TL = PT.getPointeeLoc();
       } else if (ReferenceTypeLoc RT = TL.getAs<ReferenceTypeLoc>())
         TL = RT.getPointeeLoc();
       else
         break;

clang/lib/AST/ASTContext.cpp

case Type::DeducedTemplateSpecialization: {
     assert(!A->getDeducedType().isNull() &&
            "cannot request the size of an undeduced or dependent auto type");
     return getTypeInfo(A->getDeducedType().getTypePtr());
   }
 
   case Type::Paren:
     return getTypeInfo(cast<ParenType>(T)->getInnerType().getTypePtr());
 
+  case Type::MacroQualified:
+    return getTypeInfo(
+        cast<MacroQualifiedType>(T)->getUnderlyingType().getTypePtr());
+
   case Type::ObjCTypeParam:
     return getTypeInfo(cast<ObjCTypeParamType>(T)->desugar().getTypePtr());
 
   case Type::Typedef: {
     const TypedefNameDecl *Typedef = cast<TypedefType>(T)->getDecl();
     TypeInfo Info = getTypeInfo(Typedef->getUnderlyingType().getTypePtr());
     // If the typedef has an aligned attribute on it, it overrides any computed
     // alignment we have.  This violates the GCC documentation (which says that
QualType ASTContext::getAttributedType(attr::Kind attrKind,
   AttributedType::Profile(id, attrKind, modifiedType, equivalentType);
 
   void *insertPos = nullptr;
   AttributedType *type = AttributedTypes.FindNodeOrInsertPos(id, insertPos);
   if (type) return QualType(type, 0);
 
   QualType canon = getCanonicalType(equivalentType);
   type = new (*this, TypeAlignment)
-           AttributedType(canon, attrKind, modifiedType, equivalentType);
 
   Types.push_back(type);
   AttributedTypes.InsertNode(type, insertPos);
 
   return QualType(type, 0);
 }
 
 /// Retrieve a substitution-result type.
ASTContext::getParenType(QualType InnerType) const {
   }
 
   T = new (*this, TypeAlignment) ParenType(InnerType, Canon);
   Types.push_back(T);
   ParenTypes.InsertNode(T, InsertPos);
   return QualType(T, 0);
 }
 
+QualType
+ASTContext::getMacroQualifiedType(QualType UnderlyingTy,
+                                  const IdentifierInfo *MacroII) const {
+  QualType Canon = UnderlyingTy;
+  if (!Canon.isCanonical())
+    Canon = getCanonicalType(UnderlyingTy);
+
+  auto *newType = new (*this, TypeAlignment)
+      MacroQualifiedType(UnderlyingTy, Canon, MacroII);
+  Types.push_back(newType);
+  return QualType(newType, 0);
+}
+
 QualType ASTContext::getDependentNameType(ElaboratedTypeKeyword Keyword,
                                           NestedNameSpecifier *NNS,
                                           const IdentifierInfo *Name,
                                           QualType Canon) const {
   if (Canon.isNull()) {
     NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
     if (CanonNNS != NNS)
       Canon = getDependentNameType(Keyword, CanonNNS, Name);

clang/lib/AST/ASTDiagnostic.cpp

if (const ElaboratedType *ET = dyn_cast<ElaboratedType>(Ty)) {
       QT = ET->desugar();
       continue;
     }
     // ... or a paren type ...
     if (const ParenType *PT = dyn_cast<ParenType>(Ty)) {
       QT = PT->desugar();
       continue;
     }
+    // ... or a macro defined type ...
+    if (const MacroQualifiedType *MDT = dyn_cast<MacroQualifiedType>(Ty)) {
+      QT = MDT->desugar();
+      continue;
+    }
     // ...or a substituted template type parameter ...
     if (const SubstTemplateTypeParmType *ST =
           dyn_cast<SubstTemplateTypeParmType>(Ty)) {
       QT = ST->desugar();
       continue;
     }
     // ...or an attributed type...
     if (const AttributedType *AT = dyn_cast<AttributedType>(Ty)) {

clang/lib/AST/ASTStructuralEquivalence.cpp

case Type::Attributed:
     break;
 
   case Type::Paren:
     if (!IsStructurallyEquivalent(Context, cast<ParenType>(T1)->getInnerType(),
                                   cast<ParenType>(T2)->getInnerType()))
       return false;
     break;
 
+  case Type::MacroQualified:
+    if (!IsStructurallyEquivalent(
+            Context, cast<MacroQualifiedType>(T1)->getUnderlyingType(),
+            cast<MacroQualifiedType>(T2)->getUnderlyingType()))
+      return false;
+    break;
+
   case Type::Typedef:
     if (!IsStructurallyEquivalent(Context, cast<TypedefType>(T1)->getDecl(),
                                   cast<TypedefType>(T2)->getDecl()))
       return false;
     break;
 
   case Type::TypeOfExpr:
     if (!IsStructurallyEquivalent(

clang/lib/AST/ItaniumMangle.cpp

bool CXXNameMangler::mangleUnresolvedTypeOrSimpleId(QualType Ty,
   case Type::DeducedTemplateSpecialization:
   case Type::PackExpansion:
   case Type::ObjCObject:
   case Type::ObjCInterface:
   case Type::ObjCObjectPointer:
   case Type::ObjCTypeParam:
   case Type::Atomic:
   case Type::Pipe:
+  case Type::MacroQualified:
     llvm_unreachable("type is illegal as a nested name specifier");
 
   case Type::SubstTemplateTypeParmPack:
     // FIXME: not clear how to mangle this!
     // template <class T...> class A {
     //   template <class U...> void foo(decltype(T::foo(U())) x...);
     // };
     Out << "_SUBSTPACK_";

clang/lib/AST/Type.cpp

 
 QualType QualType::IgnoreParens(QualType T) {
   // FIXME: this seems inherently un-qualifiers-safe.
   while (const auto *PT = T->getAs<ParenType>())
     T = PT->getInnerType();
   return T;
 }
 
 /// This will check for a T (which should be a Type which can act as
 /// sugar, such as a TypedefType) by removing any existing sugar until it
 /// reaches a T or a non-sugared type.
 template<typename T> static const T *getAsSugar(const Type *Cur) {
   while (true) {
     if (const auto *Sugar = dyn_cast<T>(Cur))
       return Sugar;
     switch (Cur->getTypeClass()) {
 #define ABSTRACT_TYPE(Class, Parent)
 #define TYPE(Class, Parent) \
     case Type::Class: { \
       const auto *Ty = cast<Class##Type>(Cur); \
       if (!Ty->isSugared()) return 0; \
QualType VisitParenType(const ParenType *T) {
     if (innerType.getAsOpaquePtr() == T->getInnerType().getAsOpaquePtr())
       return QualType(T, 0);
 
     return Ctx.getParenType(innerType);
   }
 
   SUGARED_TYPE_CLASS(Typedef)
   SUGARED_TYPE_CLASS(ObjCTypeParam)
+  SUGARED_TYPE_CLASS(MacroQualified)
 
   QualType VisitAdjustedType(const AdjustedType *T) {
     QualType originalType = recurse(T->getOriginalType());
     if (originalType.isNull())
       return {};
 
     QualType adjustedType = recurse(T->getAdjustedType());
     if (adjustedType.isNull())
public:
     Type *VisitParenType(const ParenType *T) {
       return Visit(T->getInnerType());
     }
 
     Type *VisitAttributedType(const AttributedType *T) {
       return Visit(T->getModifiedType());
     }
 
+    Type *VisitMacroQualifiedType(const MacroQualifiedType *T) {
+      return Visit(T->getUnderlyingType());
+    }
+
     Type *VisitAdjustedType(const AdjustedType *T) {
       return Visit(T->getOriginalType());
     }
   };
 
 } // namespace
 
 DeducedType *Type::getContainedDeducedType() const {
void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID,
   Profile(ID, getReturnType(), param_type_begin(), getNumParams(),
           getExtProtoInfo(), Ctx, isCanonicalUnqualified());
 }
 
 QualType TypedefType::desugar() const {
   return getDecl()->getUnderlyingType();
 }
 
+QualType MacroQualifiedType::desugar() const { return getUnderlyingType(); }
+
+QualType MacroQualifiedType::getModifiedType() const {
+  // Step over MacroQualifiedTypes from the same macro to find the type
+  // ultimately qualified by the macro qualifier.
+  QualType Inner = cast<AttributedType>(getUnderlyingType())->getModifiedType();
+  while (auto *InnerMQT = dyn_cast<MacroQualifiedType>(Inner)) {
+    if (InnerMQT->getMacroIdentifier() != getMacroIdentifier())
+      break;
+    Inner = InnerMQT->getModifiedType();
+  }
+  return Inner;
+}
+
 TypeOfExprType::TypeOfExprType(Expr *E, QualType can)
     : Type(TypeOfExpr, can, E->isTypeDependent(),
            E->isInstantiationDependent(),
            E->getType()->isVariablyModifiedType(),
            E->containsUnexpandedParameterPack()),
       TOExpr(E) {}
 
 bool TypeOfExprType::isSugared() const {

clang/lib/AST/TypePrinter.cpp

namespace {
   };
 
   class TypePrinter {
     PrintingPolicy Policy;
     unsigned Indentation;
     bool HasEmptyPlaceHolder = false;
     bool InsideCCAttribute = false;
 
   public:
     explicit TypePrinter(const PrintingPolicy &Policy, unsigned Indentation = 0)
         : Policy(Policy), Indentation(Indentation) {}
 
     void print(const Type *ty, Qualifiers qs, raw_ostream &OS,
                StringRef PlaceHolder);
     void print(QualType T, raw_ostream &OS, StringRef PlaceHolder);
 
     static bool canPrefixQualifiers(const Type *T, bool &NeedARCStrongQualifier);
     void spaceBeforePlaceHolder(raw_ostream &OS);
switch (TC) {
     case Type::DependentSizedExtVector:
     case Type::Vector:
     case Type::ExtVector:
     case Type::FunctionProto:
     case Type::FunctionNoProto:
     case Type::Paren:
     case Type::PackExpansion:
     case Type::SubstTemplateTypeParm:
+    case Type::MacroQualified:
       CanPrefixQualifiers = false;
       break;
 
     case Type::Attributed: {
       // We still want to print the address_space before the type if it is an
       // address_space attribute.
       const auto *AttrTy = cast<AttributedType>(T);
       CanPrefixQualifiers = AttrTy->getAttrKind() == attr::AddressSpace;

 
 void TypePrinter::printUnresolvedUsingAfter(const UnresolvedUsingType *T,
                                             raw_ostream &OS) {}
 
 void TypePrinter::printTypedefBefore(const TypedefType *T, raw_ostream &OS) {
   printTypeSpec(T->getDecl(), OS);
 }
 
+void TypePrinter::printMacroQualifiedBefore(const MacroQualifiedType *T,
+                                            raw_ostream &OS) {
+  StringRef MacroName = T->getMacroIdentifier()->getName();
+  OS << MacroName << " ";
+
+  // Since this type is meant to print the macro instead of the whole attribute,
+  // we trim any attributes and go directly to the original modified type.
+  printBefore(T->getModifiedType(), OS);
+}
+
+void TypePrinter::printMacroQualifiedAfter(const MacroQualifiedType *T,
+                                           raw_ostream &OS) {
+  printAfter(T->getModifiedType(), OS);
+}
+
 void TypePrinter::printTypedefAfter(const TypedefType *T, raw_ostream &OS) {}
 
 void TypePrinter::printTypeOfExprBefore(const TypeOfExprType *T,
                                         raw_ostream &OS) {
   OS << "typeof ";
   if (T->getUnderlyingExpr())
     T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy);
   spaceBeforePlaceHolder(OS);

clang/lib/CodeGen/CGDebugInfo.cpp

case Type::Attributed:
       T = cast<AttributedType>(T)->getEquivalentType();
       break;
     case Type::Elaborated:
       T = cast<ElaboratedType>(T)->getNamedType();
       break;
     case Type::Paren:
       T = cast<ParenType>(T)->getInnerType();
       break;
+    case Type::MacroQualified:
+      T = cast<MacroQualifiedType>(T)->getUnderlyingType();
+      break;
     case Type::SubstTemplateTypeParm:
       T = cast<SubstTemplateTypeParmType>(T)->getReplacementType();
       break;
     case Type::Auto:
     case Type::DeducedTemplateSpecialization: {
       QualType DT = cast<DeducedType>(T)->getDeducedType();
       assert(!DT.isNull() && "Undeduced types shouldn't reach here.");
       T = DT;
#include "clang/AST/TypeNodes.def"
 
   case Type::Auto:
   case Type::Attributed:
   case Type::Adjusted:
   case Type::Decayed:
   case Type::DeducedTemplateSpecialization:
   case Type::Elaborated:
   case Type::Paren:
+  case Type::MacroQualified:
   case Type::SubstTemplateTypeParm:
   case Type::TypeOfExpr:
   case Type::TypeOf:
   case Type::Decltype:
   case Type::UnaryTransform:
   case Type::PackExpansion:
     break;
   }

clang/lib/CodeGen/CodeGenFunction.cpp

case Type::FunctionNoProto:
       break;
 
     case Type::Paren:
     case Type::TypeOf:
     case Type::UnaryTransform:
     case Type::Attributed:
     case Type::SubstTemplateTypeParm:
     case Type::PackExpansion:
+    case Type::MacroQualified:
       // Keep walking after single level desugaring.
       type = type.getSingleStepDesugaredType(getContext());
       break;
 
     case Type::Typedef:
     case Type::Decltype:
     case Type::Auto:
     case Type::DeducedTemplateSpecialization:

clang/lib/Parse/ParseDecl.cpp

 static bool isAttributeLateParsed(const IdentifierInfo &II) {
 #define CLANG_ATTR_LATE_PARSED_LIST
     return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
 #include "clang/Parse/AttrParserStringSwitches.inc"
         .Default(false);
 #undef CLANG_ATTR_LATE_PARSED_LIST
 }
 
+static StringRef getSpellingForLoc(SourceLocation Loc, const SourceManager &SM,
+                                   const LangOptions &LangOpts) {
+  // Dig out the buffer where the macro name was spelled and the extents of the
+  // name so that we can render it into the expansion note.
+  std::pair<FileID, unsigned> ExpansionInfo = SM.getDecomposedLoc(Loc);
+  unsigned MacroTokenLength = Lexer::MeasureTokenLength(Loc, SM, LangOpts);
+  StringRef ExpansionBuffer = SM.getBufferData(ExpansionInfo.first);
+  return ExpansionBuffer.substr(ExpansionInfo.second, MacroTokenLength);
+}
+
+/// Attempt to find the outermost macro expansion that an attribute is contained
+/// in by collecting the start and end source locations of nested expansions.
+///
+/// Determining the correct macro expansion follows this algorithm:
+/// - If the we do not find any expansions, then there is no macro to return.
+/// - If there is exaclty 1 macro expansion, then the provided start and end
+///   expansion locs must be the start and end of the attribute.
+/// - Otherwise, if there are 2 or more expansions, none of the start and end
+///   expansion locs will match the start and end of the attribute, so we can
+///   instead default to whatever the spelling location of the second macro
+///   expansion is to get the macro.
+///
+///   Example:
+///
+///     #define AS1 __attribute__((address_space(1)))  // expansion 1
+///     #define THING2 int AS1 *q = p;  // expansion 2; get spelling loc of AS1
+///     int *p = 0;
+///     THING2;
+///
+/// In each case, the chosen start and end loc must have the same FileID.
+///
+/// Returns the macro if it is found. Otherwise it returns an empty string.
+static std::string
+FindAttributeMacroExpansion(Preprocessor &PP, SourceLocation StartLoc,
+                            SourceLocation EndLoc,
+                            SourceLocation &FoundStartLocExpansion,
+                            SourceLocation &FoundEndLocExpansion) {
+
+  llvm::SmallVector<SourceLocation, 8> StartLocs;
+  SourceManager &SM = PP.getSourceManager();
+
+  // Generate starting locations
+  while (StartLoc.isMacroID()) {
+    FileID FID = SM.getFileID(StartLoc);
+    const SrcMgr::SLocEntry *E = &SM.getSLocEntry(FID);
+    const SrcMgr::ExpansionInfo &Expansion = E->getExpansion();
+    if (!Expansion.isFunctionMacroExpansion())
+      StartLocs.push_back(StartLoc);
+    StartLoc = Expansion.getExpansionLocStart();
+  }
+
+  if (StartLocs.empty()) {
+    // No macro expansion
+    return "";
+  }
+
+  // Generate end locations
+  llvm::DenseMap<FileID, SourceLocation> EndLocs;
+  while (EndLoc.isMacroID()) {
+    FileID FID = SM.getFileID(EndLoc);
+    const SrcMgr::SLocEntry *E = &SM.getSLocEntry(FID);
+    const SrcMgr::ExpansionInfo &Expansion = E->getExpansion();
+    if (!Expansion.isFunctionMacroExpansion())
+      EndLocs[FID] = EndLoc;
+    EndLoc = Expansion.getExpansionLocEnd();
+  }
+
+  if (StartLocs.size() == 1) {
+    // We have exactly 1 macro expansion, so the attribute may be at the start
+    // and end of the macro expansion.
+    SourceLocation Loc = StartLocs.front();
+    FileID FID = SM.getFileID(Loc);
+    auto FoundEndLoc = EndLocs.find(FID);
+    if (FoundEndLoc != EndLocs.end()) {
+      FoundStartLocExpansion = Loc;
+      FoundEndLocExpansion = FoundEndLoc->second;
+
+      bool AttrStartIsInMacro =
+          (FoundStartLocExpansion.isMacroID() &&
+           Lexer::isAtStartOfMacroExpansion(FoundStartLocExpansion, SM,
+                                            PP.getLangOpts()));
+      bool AttrEndIsInMacro = (FoundEndLocExpansion.isMacroID() &&
+                               Lexer::isAtEndOfMacroExpansion(
+                                   FoundEndLocExpansion, SM, PP.getLangOpts()));
+
+      if (AttrStartIsInMacro && AttrEndIsInMacro) {
+        CharSourceRange ExpansionRange = SM.getExpansionRange(StartLoc);
+        return Lexer::getSourceText(ExpansionRange, SM, PP.getLangOpts());
+      }
+    }
+    return "";
+  }
+
+  // There are at least 2 macro expansions. The expansion we want will be the
+  // second to last one.
+  auto LocIter = StartLocs.begin();
+  ++LocIter;
+  FileID FID = SM.getFileID(*LocIter);
+  auto FoundEndLoc = EndLocs.find(FID);
+  if (FoundEndLoc != EndLocs.end()) {
+    FoundStartLocExpansion = *LocIter;
+    FoundEndLocExpansion = FoundEndLoc->second;
+
+    SourceLocation Loc = SM.getSpellingLoc(FoundStartLocExpansion);
+    return getSpellingForLoc(Loc, SM, PP.getLangOpts());
+  }
+  return "";
+}
+
 /// ParseGNUAttributes - Parse a non-empty attributes list.
 ///
 /// [GNU] attributes:
 ///         attribute
 ///         attributes attribute
 ///
 /// [GNU]  attribute:
 ///          '__attribute__' '(' '(' attribute-list ')' ')'

 /// We follow the C++ model, but don't allow junk after the identifier.
 void Parser::ParseGNUAttributes(ParsedAttributes &attrs,
                                 SourceLocation *endLoc,
                                 LateParsedAttrList *LateAttrs,
                                 Declarator *D) {
   assert(Tok.is(tok::kw___attribute) && "Not a GNU attribute list!");
 
   while (Tok.is(tok::kw___attribute)) {
-    ConsumeToken();
+    SourceLocation AttrTokLoc = ConsumeToken();
+    unsigned OldNumAttrs = attrs.size();
+    unsigned OldNumLateAttrs = LateAttrs ? LateAttrs->size() : 0;
+
     if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
                          "attribute")) {
       SkipUntil(tok::r_paren, StopAtSemi); // skip until ) or ;
       return;
     }
     if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "(")) {
       SkipUntil(tok::r_paren, StopAtSemi); // skip until ) or ;
       return;
while (Tok.is(tok::kw___attribute)) {
 
     if (ExpectAndConsume(tok::r_paren))
       SkipUntil(tok::r_paren, StopAtSemi);
     SourceLocation Loc = Tok.getLocation();
     if (ExpectAndConsume(tok::r_paren))
       SkipUntil(tok::r_paren, StopAtSemi);
     if (endLoc)
       *endLoc = Loc;
+
+    // If this was declared in a macro, attach the macro IdentifierInfo to the
+    // parsed attribute.
+    SourceLocation StartLoc, EndLoc;
+    std::string FoundName =
+        FindAttributeMacroExpansion(PP, AttrTokLoc, Loc, StartLoc, EndLoc);
+    if (!FoundName.empty()) {
+      auto &SM = PP.getSourceManager();
+      CharSourceRange ExpansionRange = SM.getExpansionRange(StartLoc);
+      IdentifierInfo *MacroII = PP.getIdentifierInfo(FoundName);
+
+      for (unsigned i = OldNumAttrs; i < attrs.size(); ++i)
+        attrs[i].setMacroIdentifier(MacroII, ExpansionRange.getBegin());
+
+      if (LateAttrs) {
+        for (unsigned i = OldNumLateAttrs; i < LateAttrs->size(); ++i)
+          (*LateAttrs)[i]->MacroII = MacroII;
+      }
+    }
   }
 }
 
 /// Determine whether the given attribute has an identifier argument.
 static bool attributeHasIdentifierArg(const IdentifierInfo &II) {
 #define CLANG_ATTR_IDENTIFIER_ARG_LIST
   return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
 #include "clang/Parse/AttrParserStringSwitches.inc"

clang/lib/Sema/SemaExpr.cpp

case Type::FunctionNoProto:
       T = cast<FunctionType>(Ty)->getReturnType();
       break;
     case Type::Paren:
     case Type::TypeOf:
     case Type::UnaryTransform:
     case Type::Attributed:
     case Type::SubstTemplateTypeParm:
     case Type::PackExpansion:
+    case Type::MacroQualified:
       // Keep walking after single level desugaring.
       T = T.getSingleStepDesugaredType(Context);
       break;
     case Type::Typedef:
       T = cast<TypedefType>(Ty)->desugar();
       break;
     case Type::Decltype:
       T = cast<DecltypeType>(Ty)->desugar();
void Sema::ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,
   // literal signature.  Furthermore, it is always a FunctionProtoType
   // unless the function was written with a typedef.
   assert(T->isFunctionType() &&
          "GetTypeForDeclarator made a non-function block signature");
 
   // Look for an explicit signature in that function type.
   FunctionProtoTypeLoc ExplicitSignature;
 
-  if ((ExplicitSignature =
-           Sig->getTypeLoc().getAsAdjusted<FunctionProtoTypeLoc>())) {
+  if ((ExplicitSignature = Sig->getTypeLoc()
+                               .getAsAdjusted<FunctionProtoTypeLoc>())) {
 
     // Check whether that explicit signature was synthesized by
     // GetTypeForDeclarator.  If so, don't save that as part of the
     // written signature.
     if (ExplicitSignature.getLocalRangeBegin() ==
         ExplicitSignature.getLocalRangeEnd()) {
       // This would be much cheaper if we stored TypeLocs instead of
       // TypeSourceInfos.
       TypeLoc Result = ExplicitSignature.getReturnLoc();

clang/lib/Sema/SemaStmt.cpp

bool LocalTypedefNameReferencer::VisitRecordType(const RecordType *RT) {
   for (auto *TmpD : R->decls())
     if (auto *T = dyn_cast<TypedefNameDecl>(TmpD))
       if (T->getAccess() != AS_private || R->hasFriends())
         S.MarkAnyDeclReferenced(T->getLocation(), T, /*OdrUse=*/false);
   return true;
 }
 }
 
 TypeLoc Sema::getReturnTypeLoc(FunctionDecl *FD) const {
-  TypeLoc TL = FD->getTypeSourceInfo()->getTypeLoc().IgnoreParens();
-  while (auto ATL = TL.getAs<AttributedTypeLoc>())
-    TL = ATL.getModifiedLoc().IgnoreParens();
-  return TL.castAs<FunctionProtoTypeLoc>().getReturnLoc();
+  return FD->getTypeSourceInfo()
+      ->getTypeLoc()
+      .getAsAdjusted<FunctionProtoTypeLoc>()
+      .getReturnLoc();
 }
 
 /// Deduce the return type for a function from a returned expression, per
 /// C++1y [dcl.spec.auto]p6.
 bool Sema::DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD,
                                             SourceLocation ReturnLoc,
                                             Expr *&RetExpr,
                                             AutoType *AT) {

clang/lib/Sema/SemaType.cpp

void VisitParenTypeLoc(ParenTypeLoc TL) {
       assert(Chunk.Kind == DeclaratorChunk::Paren);
       TL.setLParenLoc(Chunk.Loc);
       TL.setRParenLoc(Chunk.EndLoc);
     }
     void VisitPipeTypeLoc(PipeTypeLoc TL) {
       assert(Chunk.Kind == DeclaratorChunk::Pipe);
       TL.setKWLoc(Chunk.Loc);
     }
+    void VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) {
+      TL.setExpansionLoc(Chunk.Loc);
+    }
 
     void VisitTypeLoc(TypeLoc TL) {
       llvm_unreachable("unsupported TypeLoc kind in declarator!");
     }
   };
 } // end anonymous namespace
 
 static void fillAtomicQualLoc(AtomicTypeLoc ATL, const DeclaratorChunk &Chunk) {
GetTypeSourceInfoForDeclarator(TypeProcessingState &State,
   for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
     // An AtomicTypeLoc might be produced by an atomic qualifier in this
     // declarator chunk.
     if (AtomicTypeLoc ATL = CurrTL.getAs<AtomicTypeLoc>()) {
       fillAtomicQualLoc(ATL, D.getTypeObject(i));
       CurrTL = ATL.getValueLoc().getUnqualifiedLoc();
     }
 
+    while (MacroQualifiedTypeLoc TL = CurrTL.getAs<MacroQualifiedTypeLoc>())
+      CurrTL = TL.getNextTypeLoc().getUnqualifiedLoc();
+
     while (AttributedTypeLoc TL = CurrTL.getAs<AttributedTypeLoc>()) {
       fillAttributedTypeLoc(TL, State);
       CurrTL = TL.getNextTypeLoc().getUnqualifiedLoc();
     }
 
     while (DependentAddressSpaceTypeLoc TL =
                CurrTL.getAs<DependentAddressSpaceTypeLoc>()) {
       fillDependentAddressSpaceTypeLoc(TL, D.getTypeObject(i).getAttrs());
static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr,
   } else {
     auto EI = unwrapped.get()->getExtInfo().withCallingConv(CC);
     Equivalent =
       unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
   }
   type = state.getAttributedType(CCAttr, type, Equivalent);
   return true;
 }
 
-bool Sema::hasExplicitCallingConv(QualType &T) {
-  QualType R = T.IgnoreParens();
-  while (const AttributedType *AT = dyn_cast<AttributedType>(R)) {
+bool Sema::hasExplicitCallingConv(QualType T) {
+  const AttributedType *AT;
+
+  // Stop if we'd be stripping off a typedef sugar node to reach the
+  // AttributedType.
+  while ((AT = T->getAs<AttributedType>()) &&
+         AT->getAs<TypedefType>() == T->getAs<TypedefType>()) {
     if (AT->isCallingConv())
       return true;
-    R = AT->getModifiedType().IgnoreParens();
+    T = AT->getModifiedType();
   }
   return false;
 }
 
 void Sema::adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor,
                                   SourceLocation Loc) {
   FunctionTypeUnwrapper Unwrapped(*this, T);
   const FunctionType *FT = Unwrapped.get();
   bool IsVariadic = (isa<FunctionProtoType>(FT) &&
static void processTypeAttrs(TypeProcessingState &state, QualType &type,
   // type, but others can be present in the type specifiers even though they
   // apply to the decl.  Here we apply type attributes and ignore the rest.
 
   // This loop modifies the list pretty frequently, but we still need to make
   // sure we visit every element once. Copy the attributes list, and iterate
   // over that.
   ParsedAttributesView AttrsCopy{attrs};
 
   state.setParsedNoDeref(false);
 
   for (ParsedAttr &attr : AttrsCopy) {
 
     // Skip attributes that were marked to be invalid.
     if (attr.isInvalid())
       continue;
 
     if (attr.isCXX11Attribute()) {
FUNCTION_TYPE_ATTRS_CASELIST:
       if (TAL == TAL_DeclSpec)
         distributeFunctionTypeAttrFromDeclSpec(state, attr, type);
 
       // Otherwise, handle the possible delays.
       else if (!handleFunctionTypeAttr(state, attr, type))
         distributeFunctionTypeAttr(state, attr, type);
       break;
     }
+
+    // Handle attributes that are defined in a macro. We do not want this to be
+    // applied to ObjC builtin attributes.
+    if (isa<AttributedType>(type) && attr.hasMacroIdentifier() &&
+        !type.getQualifiers().hasObjCLifetime() &&
+        !type.getQualifiers().hasObjCGCAttr()) {
+      const IdentifierInfo *MacroII = attr.getMacroIdentifier();
+      type = state.getSema().Context.getMacroQualifiedType(type, MacroII);
+    }
   }
 
   if (!state.getSema().getLangOpts().OpenCL ||
       type.getAddressSpace() != LangAS::Default)
     return;
 
   deduceOpenCLImplicitAddrSpace(state, type, TAL);
 }

clang/lib/Sema/TreeTransform.h

#include "clang/Basic/OpenMPKinds.def"
   /// the UnresolvedUsingTypenameDecl was transformed to.
   QualType RebuildUnresolvedUsingType(SourceLocation NameLoc, Decl *D);
 
   /// Build a new typedef type.
   QualType RebuildTypedefType(TypedefNameDecl *Typedef) {
     return SemaRef.Context.getTypeDeclType(Typedef);
   }
 
+  /// Build a new MacroDefined type.
+  QualType RebuildMacroQualifiedType(QualType T,
+                                     const IdentifierInfo *MacroII) {
+    return SemaRef.Context.getMacroQualifiedType(T, MacroII);
+  }
+
   /// Build a new class/struct/union type.
   QualType RebuildRecordType(RecordDecl *Record) {
     return SemaRef.Context.getTypeDeclType(Record);
   }
 
   /// Build a new Enum type.
   QualType RebuildEnumType(EnumDecl *Enum) {
     return SemaRef.Context.getTypeDeclType(Enum);
TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB,
   }
 
   ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result);
   NewTL.setLParenLoc(TL.getLParenLoc());
   NewTL.setRParenLoc(TL.getRParenLoc());
   return Result;
 }
 
-template<typename Derived>
+template <typename Derived>
+QualType
+TreeTransform<Derived>::TransformMacroQualifiedType(TypeLocBuilder &TLB,
+                                                    MacroQualifiedTypeLoc TL) {
+  QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
+  if (Inner.isNull())
+    return QualType();
+
+  QualType Result = TL.getType();
+  if (getDerived().AlwaysRebuild() || Inner != TL.getInnerLoc().getType()) {
+    Result =
+        getDerived().RebuildMacroQualifiedType(Inner, TL.getMacroIdentifier());
+    if (Result.isNull())
+      return QualType();
+  }
+
+  MacroQualifiedTypeLoc NewTL = TLB.push<MacroQualifiedTypeLoc>(Result);
+  NewTL.setExpansionLoc(TL.getExpansionLoc());
+  return Result;
+}
+
+template<typename Derived>
 QualType TreeTransform<Derived>::TransformDependentNameType(
     TypeLocBuilder &TLB, DependentNameTypeLoc TL) {
   return TransformDependentNameType(TLB, TL, false);
 }
 
 template<typename Derived>
 QualType TreeTransform<Derived>::TransformDependentNameType(
     TypeLocBuilder &TLB, DependentNameTypeLoc TL, bool DeducedTSTContext) {

clang/lib/Serialization/ASTReader.cpp

case TYPE_PAREN: {
     if (Record.size() != 1) {
       Error("incorrect encoding of paren type");
       return QualType();
     }
     QualType InnerType = readType(*Loc.F, Record, Idx);
     return Context.getParenType(InnerType);
   }
 
+  case TYPE_MACRO_QUALIFIED: {
+    if (Record.size() != 2) {
+      Error("incorrect encoding of macro defined type");
+      return QualType();
+    }
+    QualType UnderlyingTy = readType(*Loc.F, Record, Idx);
+    IdentifierInfo *MacroII = GetIdentifierInfo(*Loc.F, Record, Idx);
+    return Context.getMacroQualifiedType(UnderlyingTy, MacroII);
+  }
+
   case TYPE_PACK_EXPANSION: {
     if (Record.size() != 2) {
       Error("incorrect encoding of pack expansion type");
       return QualType();
     }
     QualType Pattern = readType(*Loc.F, Record, Idx);
     if (Pattern.isNull())
       return QualType();

 void TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
   // nothing to do
 }
 
 void TypeLocReader::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
   // nothing to do
 }
 
+void TypeLocReader::VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) {
+  TL.setExpansionLoc(ReadSourceLocation());
+}
+
 void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
   TL.setCaretLoc(ReadSourceLocation());
 }
 
 void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
   TL.setAmpLoc(ReadSourceLocation());
 }
 

clang/lib/Serialization/ASTWriter.cpp

void ASTTypeWriter::VisitPackExpansionType(const PackExpansionType *T) {
   Code = TYPE_PACK_EXPANSION;
 }
 
 void ASTTypeWriter::VisitParenType(const ParenType *T) {
   Record.AddTypeRef(T->getInnerType());
   Code = TYPE_PAREN;
 }
 
+void ASTTypeWriter::VisitMacroQualifiedType(const MacroQualifiedType *T) {
+  Record.AddTypeRef(T->getUnderlyingType());
+  Record.AddIdentifierRef(T->getMacroIdentifier());
+  Code = TYPE_MACRO_QUALIFIED;
+}
+
 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;
 }
 
Record.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(),
                                       TL.getArgLoc(i).getLocInfo());
 }
 
 void TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) {
   Record.AddSourceLocation(TL.getLParenLoc());
   Record.AddSourceLocation(TL.getRParenLoc());
 }
 
+void TypeLocWriter::VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) {
+  Record.AddSourceLocation(TL.getExpansionLoc());
+}
+
 void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
   Record.AddSourceLocation(TL.getElaboratedKeywordLoc());
   Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc());
 }
 
 void TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
   RECORD(TYPE_INJECTED_CLASS_NAME);
   RECORD(TYPE_OBJC_OBJECT);
   RECORD(TYPE_TEMPLATE_TYPE_PARM);
   RECORD(TYPE_TEMPLATE_SPECIALIZATION);
   RECORD(TYPE_DEPENDENT_NAME);
   RECORD(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION);
   RECORD(TYPE_DEPENDENT_SIZED_ARRAY);
   RECORD(TYPE_PAREN);
+  RECORD(TYPE_MACRO_QUALIFIED);
   RECORD(TYPE_PACK_EXPANSION);
   RECORD(TYPE_ATTRIBUTED);
   RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK);
   RECORD(TYPE_AUTO);
   RECORD(TYPE_UNARY_TRANSFORM);
   RECORD(TYPE_ATOMIC);
   RECORD(TYPE_DECAYED);
   RECORD(TYPE_ADJUSTED);

clang/test/Frontend/macro_defined_type.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+#define NODEREF __attribute__((noderef))
+
+void Func() {
+  int NODEREF i; // expected-warning{{'noderef' can only be used on an array or pointer type}}
+  int NODEREF *i_ptr;
+
+  // There should be no difference whether a macro defined type is used or not.
+  auto __attribute__((noderef)) *auto_i_ptr = i_ptr;
+  auto __attribute__((noderef)) auto_i = i; // expected-warning{{'noderef' can only be used on an array or pointer type}}
+
+  auto NODEREF *auto_i_ptr2 = i_ptr;
+  auto NODEREF auto_i2 = i; // expected-warning{{'noderef' can only be used on an array or pointer type}}
+}

clang/test/Sema/address_space_print_macro.c

+// RUN: %clang_cc1 %s -fsyntax-only -verify
+
+#define AS1 __attribute__((address_space(1)))
+#define AS2 __attribute__((address_space(2), annotate("foo")))
+#define AS_ND __attribute__((address_space(2), noderef))
+
+#define AS(i) address_space(i)
+#define AS3 __attribute__((AS(3)))
+#define AS5 __attribute__((address_space(5))) char
+
+void normal_case() {
+  int *p = 0;
+  __attribute__((address_space(1))) int *q = p; // expected-error{{initializing '__attribute__((address_space(1))) int *' with an expression of type 'int *' changes address space of pointer}}
+}
+
+char *cmp(AS1 char *x, AS2 char *y) {
+  return x < y ? x : y; // expected-error{{conditional operator with the second and third operands of type  ('AS1 char *' and 'AS2 char *') which are pointers to non-overlapping address spaces}}
+}
+
+__attribute__((address_space(1))) char test_array[10];
+void test3(void) {
+  extern void test3_helper(char *p); // expected-note{{passing argument to parameter 'p' here}}
+  test3_helper(test_array);          // expected-error{{passing '__attribute__((address_space(1))) char *' to parameter of type 'char *' changes address space of pointer}}
+}
+
+char AS2 *test4_array;
+void test4(void) {
+  extern void test3_helper(char *p); // expected-note{{passing argument to parameter 'p' here}}
+  test3_helper(test4_array);         // expected-error{{passing 'AS2 char *' to parameter of type 'char *' changes address space of pointer}}
+}
+
+void func() {
+  char AS1 *x;
+  char AS3 *x2;
+  AS5 *x3;
+  char *y;
+  y = x;  // expected-error{{assigning 'AS1 char *' to 'char *' changes address space of pointer}}
+  y = x2; // expected-error{{assigning 'AS3 char *' to 'char *' changes address space of pointer}}
+  y = x3; // expected-error{{assigning '__attribute__((address_space(5))) char *' to 'char *' changes address space of pointer}}
+}
+
+void multiple_attrs(AS_ND int *x) {
+  __attribute__((address_space(2))) int *y = x; // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}}
+}
+
+void override_macro_name() {
+#define ATTRS __attribute__((noderef)) // expected-note{{previous definition is here}}
+  ATTRS
+#define ATTRS __attribute__((address_space(1))) // expected-warning{{'ATTRS' macro redefined}}
+  ATTRS
+  int *x;
+
+  int AS_ND *y = x; // expected-error{{initializing 'AS_ND int *' with an expression of type 'ATTRS int *' changes address space of pointer}}
+}
+
+void partial_macro_declaration() {
+#define ATTRS2 __attribute__((noderef))
+  ATTRS2 __attribute__((address_space(1))) int *x;
+
+  int AS_ND *y = x; // expected-error{{initializing 'AS_ND int *' with an expression of type 'ATTRS2 int __attribute__((address_space(1))) *' changes address space of pointer}}
+
+  // The attribute not wrapped with a macro should be printed regularly.
+#define ATTRS3 __attribute__((address_space(1)))
+  ATTRS3 __attribute__((noderef)) int *x2;
+
+  int AS_ND *y2 = x2; // expected-error{{initializing 'AS_ND int *' with an expression of type 'ATTRS3 int * __attribute__((noderef))' changes address space of pointer}}
+}
+
+void nested_macros() {
+#define THING \
+  int *p = 0; \
+  AS1 int *q = p;
+
+  THING; // expected-error{{initializing 'AS1 int *' with an expression of type 'int *' changes address space of pointer}}
+
+#define THING2 int AS1 *q2 = p2;
+  int *p2 = 0;
+  THING2; // expected-error{{initializing 'AS1 int *' with an expression of type 'int *' changes address space of pointer}}
+}
+
+void more_nested_macros() {
+#define THING3 THING2
+  int *p2 = 0;
+  THING3; // expected-error{{initializing 'AS1 int *' with an expression of type 'int *' changes address space of pointer}}
+}
+
+void even_more_nested_macros() {
+#define THING4 THING3
+  int *p2 = 0;
+  THING4; // expected-error{{initializing 'AS1 int *' with an expression of type 'int *' changes address space of pointer}}
+}

clang/test/Sema/address_spaces.c

void access_as_field()
     (void) bar.as_field;
 }
 
 typedef int PR4997 __attribute__((address_space(Foobar))); // expected-error {{use of undeclared identifier 'Foobar'}}
 __attribute__((address_space("12"))) int *i; // expected-error {{'address_space' attribute requires an integer constant}}
 
 // Clang extension doesn't forbid operations on pointers to different address spaces.
 char* cmp(_AS1 char *x,  _AS2 char *y) {
-  return x < y ? x : y; // expected-error{{conditional operator with the second and third operands of type  ('__attribute__((address_space(1))) char *' and '__attribute__((address_space(2))) char *') which are pointers to non-overlapping address spaces}}
+  return x < y ? x : y; // expected-error{{conditional operator with the second and third operands of type  ('_AS1 char *' and '_AS2 char *') which are pointers to non-overlapping address spaces}}
 }
 
 struct SomeStruct {
   int a;
   long b;
   int c;
 };
 
 // Compound literals in function scope are lvalues with automatic storage duration,
 // so they cannot realistically be qualified with an address space.
 void as_compound_literal() {
   (_AS1 struct SomeStruct){1, 2, 3}; // expected-error {{compound literal in function scope may not be qualified with an address space}}
   (_AS1 char[]){"test"}; // expected-error {{compound literal in function scope may not be qualified with an address space}}
   (_AS1 char[]){'a', 'b', 'c'}; // expected-error {{compound literal in function scope may not be qualified with an address space}}
 }

clang/test/SemaObjC/externally-retained.m

 @end
 
 void (^blk)(ObjCTy *, ObjCTy *) =
     ^(__strong ObjCTy *first, ObjCTy *second) EXT_RET {
   first = 0;
   second = 0; // expected-error{{variable declared with 'objc_externally_retained' cannot be modified in ARC}}
 };
 
+void (^blk2)(ObjCTy *, ObjCTy *) =
+    ^(__strong ObjCTy *first, ObjCTy *second) __attribute__((objc_externally_retained)) {
+  first = 0;
+  second = 0; // expected-error{{variable declared with 'objc_externally_retained' cannot be modified in ARC}}
+};
+
 void test8(EXT_RET ObjCTy *x) {} // expected-warning{{'objc_externally_retained' attribute only applies to variables}}
 
 #pragma clang attribute ext_ret.push(__attribute__((objc_externally_retained)), apply_to=any(function, block, objc_method))
 void test9(ObjCTy *first, __strong ObjCTy *second) {
   first = 0; // expected-error{{variable declared with 'objc_externally_retained' cannot be modified in ARC}}
   second = 0;
 }
 void (^test10)(ObjCTy *first, ObjCTy *second) = ^(ObjCTy *first, __strong ObjCTy *second) {

clang/test/SemaObjC/gc-attributes.m

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fobjc-gc -fsyntax-only -verify %s
 
 @interface A
 @end
 
 void f0(__strong A**); // expected-note{{passing argument to parameter here}}
 
 void test_f0() {
   A *a;
   static __weak A *a2;
   f0(&a);
-  f0(&a2); // expected-warning{{passing 'A *__weak *' to parameter of type 'A *__strong *' discards qualifiers}} 
+  f0(&a2); // expected-warning{{passing 'A *__weak *' to parameter of type 'A *__strong *' discards qualifiers}}
 }
 
 void f1(__weak A**); // expected-note{{passing argument to parameter here}}
 
 void test_f1() {
   A *a;
   __strong A *a2;
   f1(&a);
-  f1(&a2); // expected-warning{{passing 'A *__strong *' to parameter of type 'A *__weak *' discards qualifiers}} 
+  f1(&a2); // expected-warning{{passing 'A *__strong *' to parameter of type 'A *__weak *' discards qualifiers}}
 }
 
 // These qualifiers should silently expand to nothing in GC mode.
 void test_unsafe_unretained(__unsafe_unretained id *x) {}
 void test_autoreleasing(__autoreleasing id *x) {}

clang/test/SemaObjC/mrc-weak.m

 void test_unsafe_unretained_cast(id *value) {
   __unsafe_unretained id *a = (__unsafe_unretained id*) value;
   id *b = (__unsafe_unretained id*) value;
   __unsafe_unretained id *c = (id*) value;
 }
 
 void test_cast_qualifier_inference(__weak id *value) {
   __weak id *a = (id*) value;
-  __unsafe_unretained id *b = (id*) value; // expected-error {{initializing 'id *' with an expression of type '__weak id *' changes retain/release properties of pointer}}
+  __unsafe_unretained id *b = (id *)value; // expected-error {{initializing '__unsafe_unretained id *' with an expression of type '__weak id *' changes retain/release properties of pointer}}
 }
 

clang/test/SemaObjCXX/gc-attributes.mm

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fobjc-gc -fsyntax-only -verify %s
 
 @interface A
 @end
 
-void f0(__strong A**); // expected-note{{candidate function not viable: 1st argument ('A *__weak *') has __weak ownership, but parameter has __strong ownership}}
+void f0(__strong A **); // expected-note{{candidate function not viable: 1st argument ('A *__weak *') has __weak ownership, but parameter has __strong ownership}}
 
 void test_f0() {
   A *a;
   static __weak A *a2;
   f0(&a);
   f0(&a2); // expected-error{{no matching function}}
 }
 
-void f1(__weak A**); // expected-note{{candidate function not viable: 1st argument ('A *__strong *') has __strong ownership, but parameter has __weak ownership}}
+void f1(__weak A **); // expected-note{{candidate function not viable: 1st argument ('A *__strong *') has __strong ownership, but parameter has __weak ownership}}
 
 void test_f1() {
   A *a;
   __strong A *a2;
   f1(&a);
   f1(&a2); // expected-error{{no matching function}}
 }

clang/tools/libclang/CIndex.cpp

 bool CursorVisitor::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
   return Visit(TL.getPointeeLoc());
 }
 
 bool CursorVisitor::VisitParenTypeLoc(ParenTypeLoc TL) {
   return Visit(TL.getInnerLoc());
 }
 
+bool CursorVisitor::VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) {
+  return Visit(TL.getInnerLoc());
+}
+
 bool CursorVisitor::VisitPointerTypeLoc(PointerTypeLoc TL) {
   return Visit(TL.getPointeeLoc());
 }
 
 bool CursorVisitor::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
   return Visit(TL.getPointeeLoc());
 }