Skip to content

Commit 893f10b

Browse files
rxweirxwei
committed
[Macros] Support module-qualified attached macro lookup
Allow attached macro expansion syntax to have a module qualifier, `@Foo.Bar`. rdar://108621205
1 parent 4d8dab0 commit 893f10b

16 files changed

+202
-54
lines changed

‎include/swift/AST/Decl.h

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8591,6 +8591,8 @@ class MacroDecl : public GenericContext, public ValueDecl {
85918591
/// declaration/expression nodes.
85928592
struct MacroExpansionInfo : ASTAllocated<MacroExpansionInfo> {
85938593
SourceLoc SigilLoc;
8594+
DeclNameRef ModuleName;
8595+
DeclNameLoc ModuleNameLoc;
85948596
DeclNameRef MacroName;
85958597
DeclNameLoc MacroNameLoc;
85968598
SourceLoc LeftAngleLoc, RightAngleLoc;
@@ -8601,12 +8603,15 @@ struct MacroExpansionInfo : ASTAllocated<MacroExpansionInfo> {
86018603
ConcreteDeclRef macroRef;
86028604

86038605
MacroExpansionInfo(SourceLoc sigilLoc,
8606+
DeclNameRef moduleName,
8607+
DeclNameLoc moduleNameLoc,
86048608
DeclNameRef macroName,
86058609
DeclNameLoc macroNameLoc,
86068610
SourceLoc leftAngleLoc, SourceLoc rightAngleLoc,
86078611
ArrayRef<TypeRepr *> genericArgs,
86088612
ArgumentList *argList)
8609-
: SigilLoc(sigilLoc), MacroName(macroName), MacroNameLoc(macroNameLoc),
8613+
: SigilLoc(sigilLoc), ModuleName(moduleName), ModuleNameLoc(moduleNameLoc),
8614+
MacroName(macroName), MacroNameLoc(macroNameLoc),
86108615
LeftAngleLoc(leftAngleLoc), RightAngleLoc(rightAngleLoc),
86118616
GenericArgs(genericArgs), ArgList(argList) { }
86128617
};

‎include/swift/AST/Expr.h

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6208,7 +6208,10 @@ class MacroExpansionExpr final : public Expr {
62086208
}
62096209

62106210
explicit MacroExpansionExpr(DeclContext *dc,
6211-
SourceLoc sigilLoc, DeclNameRef macroName,
6211+
SourceLoc sigilLoc,
6212+
DeclNameRef moduleName,
6213+
DeclNameLoc moduleNameLoc,
6214+
DeclNameRef macroName,
62126215
DeclNameLoc macroNameLoc,
62136216
SourceLoc leftAngleLoc,
62146217
ArrayRef<TypeRepr *> genericArgs,
@@ -6218,6 +6221,8 @@ class MacroExpansionExpr final : public Expr {
62186221
bool isImplicit = false,
62196222
Type ty = Type());
62206223

6224+
DeclNameRef getModuleName() const { return info->ModuleName; }
6225+
DeclNameLoc getModuleNameLoc() const { return info->ModuleNameLoc; }
62216226
DeclNameRef getMacroName() const { return info->MacroName; }
62226227
DeclNameLoc getMacroNameLoc() const { return info->MacroNameLoc; }
62236228

‎include/swift/AST/TypeCheckRequests.h

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3226,6 +3226,8 @@ class UnresolvedMacroReference {
32263226
}
32273227

32283228
SourceLoc getSigilLoc() const;
3229+
DeclNameRef getModuleName() const;
3230+
DeclNameLoc getModuleNameLoc() const;
32293231
DeclNameRef getMacroName() const;
32303232
DeclNameLoc getMacroNameLoc() const;
32313233
SourceRange getGenericArgsRange() const;

‎lib/AST/Decl.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -10566,8 +10566,8 @@ MacroExpansionDecl::MacroExpansionDecl(
1056610566
) : Decl(DeclKind::MacroExpansion, dc) {
1056710567
ASTContext &ctx = dc->getASTContext();
1056810568
info = new (ctx) MacroExpansionInfo{
10569-
poundLoc, macro, macroLoc,
10570-
leftAngleLoc, rightAngleLoc, genericArgs,
10569+
poundLoc, /*moduleName*/ DeclNameRef(), /*moduleNameLoc*/ DeclNameLoc(),
10570+
macro, macroLoc, leftAngleLoc, rightAngleLoc, genericArgs,
1057110571
args ? args : ArgumentList::createImplicit(ctx, {})
1057210572
};
1057310573
Bits.MacroExpansionDecl.Discriminator = InvalidDiscriminator;

‎lib/AST/Expr.cpp

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2713,7 +2713,8 @@ TypeJoinExpr::forBranchesOfSingleValueStmtExpr(ASTContext &ctx, Type joinType,
27132713
}
27142714

27152715
MacroExpansionExpr::MacroExpansionExpr(
2716-
DeclContext *dc, SourceLoc sigilLoc, DeclNameRef macroName,
2716+
DeclContext *dc, SourceLoc sigilLoc, DeclNameRef moduleName,
2717+
DeclNameLoc moduleNameLoc, DeclNameRef macroName,
27172718
DeclNameLoc macroNameLoc, SourceLoc leftAngleLoc,
27182719
ArrayRef<TypeRepr *> genericArgs, SourceLoc rightAngleLoc,
27192720
ArgumentList *argList, MacroRoles roles, bool isImplicit,
@@ -2722,7 +2723,7 @@ MacroExpansionExpr::MacroExpansionExpr(
27222723
Rewritten(nullptr), Roles(roles), SubstituteDecl(nullptr) {
27232724
ASTContext &ctx = dc->getASTContext();
27242725
info = new (ctx) MacroExpansionInfo{
2725-
sigilLoc, macroName, macroNameLoc,
2726+
sigilLoc, moduleName, moduleNameLoc, macroName, macroNameLoc,
27262727
leftAngleLoc, rightAngleLoc, genericArgs,
27272728
argList ? argList : ArgumentList::createImplicit(ctx, {})
27282729
};

‎lib/AST/NameLookup.cpp

Lines changed: 40 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -3269,15 +3269,51 @@ GenericParamListRequest::evaluate(Evaluator &evaluator, GenericContext *value) c
32693269

32703270
void swift::findMacroForCustomAttr(CustomAttr *attr, DeclContext *dc,
32713271
llvm::TinyPtrVector<ValueDecl *> &macros) {
3272-
auto *identTypeRepr = dyn_cast_or_null<IdentTypeRepr>(attr->getTypeRepr());
3273-
if (!identTypeRepr)
3274-
return;
3275-
32763272
// Look for macros at module scope. They can only occur at module scope, and
32773273
// we need to be sure not to trigger name lookup into type contexts along
32783274
// the way.
32793275
auto moduleScopeDC = dc->getModuleScopeContext();
32803276
ASTContext &ctx = moduleScopeDC->getASTContext();
3277+
3278+
// Handle a module-qualified name.
3279+
if (auto *memTypeRepr = dyn_cast_or_null<MemberTypeRepr>(attr->getTypeRepr())) {
3280+
auto baseTypeRepr = memTypeRepr->getBaseComponent();
3281+
auto *moduleNameRepr = dyn_cast<IdentTypeRepr>(baseTypeRepr);
3282+
auto memberReprs = memTypeRepr->getMemberComponents();
3283+
if (!moduleNameRepr || memberReprs.size() != 1)
3284+
return;
3285+
auto moduleName = moduleNameRepr->getNameRef();
3286+
auto *macroNameRepr = dyn_cast<IdentTypeRepr>(memberReprs.front());
3287+
if (!macroNameRepr)
3288+
return;
3289+
auto macroName = macroNameRepr->getNameRef();
3290+
3291+
UnqualifiedLookupDescriptor moduleLookupDesc(
3292+
moduleName, moduleScopeDC, SourceLoc(),
3293+
UnqualifiedLookupFlags::TypeLookup);
3294+
auto moduleLookup = evaluateOrDefault(
3295+
ctx.evaluator, UnqualifiedLookupRequest{moduleLookupDesc}, {});
3296+
auto foundTypeDecl = moduleLookup.getSingleTypeResult();
3297+
auto *moduleDecl = dyn_cast_or_null<ModuleDecl>(foundTypeDecl);
3298+
if (!moduleDecl)
3299+
return;
3300+
3301+
ModuleQualifiedLookupRequest req{
3302+
moduleScopeDC, moduleDecl, macroName, NL_ExcludeMacroExpansions};
3303+
auto lookup = evaluateOrDefault(ctx.evaluator, req, {});
3304+
for (auto *found : lookup)
3305+
// Only keep attached macros, which can be spelled as custom attributes.
3306+
if (auto macro = dyn_cast<MacroDecl>(found))
3307+
if (isAttachedMacro(macro->getMacroRoles()))
3308+
macros.push_back(macro);
3309+
return;
3310+
}
3311+
3312+
// Handle an unqualified name.
3313+
auto *identTypeRepr = dyn_cast_or_null<IdentTypeRepr>(attr->getTypeRepr());
3314+
if (!identTypeRepr)
3315+
return;
3316+
32813317
UnqualifiedLookupDescriptor descriptor(
32823318
identTypeRepr->getNameRef(), moduleScopeDC
32833319
);

‎lib/AST/TypeCheckRequests.cpp

Lines changed: 63 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -1680,27 +1680,76 @@ void swift::simple_display(
16801680
// ResolveMacroRequest computation.
16811681
//----------------------------------------------------------------------------//
16821682

1683-
DeclNameRef UnresolvedMacroReference::getMacroName() const {
1683+
SourceLoc UnresolvedMacroReference::getSigilLoc() const {
16841684
if (auto *med = pointer.dyn_cast<MacroExpansionDecl *>())
1685-
return med->getMacroName();
1685+
return med->getPoundLoc();
16861686
if (auto *mee = pointer.dyn_cast<MacroExpansionExpr *>())
1687-
return mee->getMacroName();
1687+
return mee->getLoc();
1688+
if (auto *attr = pointer.dyn_cast<CustomAttr *>())
1689+
return attr->getRangeWithAt().Start;
1690+
llvm_unreachable("Unhandled case");
1691+
}
1692+
1693+
/// Destructure a type repr for a macro reference.
1694+
///
1695+
/// For a 1-level member type repr whose base and member are both identifier
1696+
/// types, e.g. `Foo.Bar`, return a pair of the base and the member.
1697+
///
1698+
/// For an identifier type repr, return a pair of `nullptr` and the identifier.
1699+
static std::pair<IdentTypeRepr *, IdentTypeRepr *>
1700+
destructureMacroRefTypeRepr(TypeRepr *typeRepr) {
1701+
if (!typeRepr)
1702+
return {nullptr, nullptr};
1703+
if (auto *identType = dyn_cast<IdentTypeRepr>(typeRepr))
1704+
return {nullptr, identType};
1705+
if (auto *memType = dyn_cast<MemberTypeRepr>(typeRepr))
1706+
if (auto *base = dyn_cast<IdentTypeRepr>(memType->getBaseComponent()))
1707+
if (memType->getMemberComponents().size() == 1)
1708+
if (auto first = dyn_cast<IdentTypeRepr>(
1709+
memType->getMemberComponents().front()))
1710+
return {base, first};
1711+
return {nullptr, nullptr};
1712+
}
1713+
1714+
DeclNameRef UnresolvedMacroReference::getModuleName() const {
1715+
if (auto *med = pointer.dyn_cast<MacroExpansionDecl *>())
1716+
return DeclNameRef();
1717+
if (auto *mee = pointer.dyn_cast<MacroExpansionExpr *>())
1718+
return mee->getModuleName();
16881719
if (auto *attr = pointer.dyn_cast<CustomAttr *>()) {
1689-
auto *identTypeRepr = dyn_cast_or_null<IdentTypeRepr>(attr->getTypeRepr());
1690-
if (!identTypeRepr)
1720+
auto [base, _] = destructureMacroRefTypeRepr(attr->getTypeRepr());
1721+
if (!base)
16911722
return DeclNameRef();
1692-
return identTypeRepr->getNameRef();
1723+
return base->getNameRef();
16931724
}
16941725
llvm_unreachable("Unhandled case");
16951726
}
16961727

1697-
SourceLoc UnresolvedMacroReference::getSigilLoc() const {
1728+
DeclNameLoc UnresolvedMacroReference::getModuleNameLoc() const {
16981729
if (auto *med = pointer.dyn_cast<MacroExpansionDecl *>())
1699-
return med->getPoundLoc();
1730+
return DeclNameLoc();
17001731
if (auto *mee = pointer.dyn_cast<MacroExpansionExpr *>())
1701-
return mee->getLoc();
1702-
if (auto *attr = pointer.dyn_cast<CustomAttr *>())
1703-
return attr->getRangeWithAt().Start;
1732+
return mee->getModuleNameLoc();
1733+
if (auto *attr = pointer.dyn_cast<CustomAttr *>()) {
1734+
auto [base, _] = destructureMacroRefTypeRepr(attr->getTypeRepr());
1735+
if (!base)
1736+
return DeclNameLoc();
1737+
return base->getNameLoc();
1738+
}
1739+
llvm_unreachable("Unhandled case");
1740+
}
1741+
1742+
DeclNameRef UnresolvedMacroReference::getMacroName() const {
1743+
if (auto *med = pointer.dyn_cast<MacroExpansionDecl *>())
1744+
return med->getMacroName();
1745+
if (auto *mee = pointer.dyn_cast<MacroExpansionExpr *>())
1746+
return mee->getMacroName();
1747+
if (auto *attr = pointer.dyn_cast<CustomAttr *>()) {
1748+
auto [_, member] = destructureMacroRefTypeRepr(attr->getTypeRepr());
1749+
if (!member)
1750+
return DeclNameRef();
1751+
return member->getNameRef();
1752+
}
17041753
llvm_unreachable("Unhandled case");
17051754
}
17061755

@@ -1710,10 +1759,10 @@ DeclNameLoc UnresolvedMacroReference::getMacroNameLoc() const {
17101759
if (auto *mee = pointer.dyn_cast<MacroExpansionExpr *>())
17111760
return mee->getMacroNameLoc();
17121761
if (auto *attr = pointer.dyn_cast<CustomAttr *>()) {
1713-
auto *identTypeRepr = dyn_cast_or_null<IdentTypeRepr>(attr->getTypeRepr());
1714-
if (!identTypeRepr)
1762+
auto [_, member] = destructureMacroRefTypeRepr(attr->getTypeRepr());
1763+
if (!member)
17151764
return DeclNameLoc();
1716-
return identTypeRepr->getNameLoc();
1765+
return member->getNameLoc();
17171766
}
17181767
llvm_unreachable("Unhandled case");
17191768
}

‎lib/Parse/ParseDecl.cpp

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -9806,7 +9806,6 @@ Parser::parseDeclMacroExpansion(ParseDeclOptions flags,
98069806
return makeParserResult(
98079807
status,
98089808
new (Context) MacroExpansionDecl(
9809-
CurDeclContext, poundLoc, macroNameRef, macroNameLoc,
9810-
leftAngleLoc, Context.AllocateCopy(genericArgs), rightAngleLoc,
9811-
argList));
9809+
CurDeclContext, poundLoc, macroNameRef, macroNameLoc, leftAngleLoc,
9810+
Context.AllocateCopy(genericArgs), rightAngleLoc, argList));
98129811
}

‎lib/Parse/ParseExpr.cpp

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3413,8 +3413,9 @@ ParserResult<Expr> Parser::parseExprMacroExpansion(bool isExprBasic) {
34133413
return makeParserResult(
34143414
status,
34153415
new (Context) MacroExpansionExpr(
3416-
CurDeclContext, poundLoc, macroNameRef, macroNameLoc, leftAngleLoc,
3417-
Context.AllocateCopy(genericArgs), rightAngleLoc, argList,
3416+
CurDeclContext, poundLoc, DeclNameRef(), DeclNameLoc(), macroNameRef,
3417+
macroNameLoc, leftAngleLoc, Context.AllocateCopy(genericArgs),
3418+
rightAngleLoc, argList,
34183419
CurDeclContext->isTypeContext()
34193420
? MacroRole::Declaration
34203421
: getFreestandingMacroRoles()));

‎lib/Sema/CSApply.cpp

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -2938,9 +2938,10 @@ namespace {
29382938
auto macro = cast<MacroDecl>(overload.choice.getDecl());
29392939
ConcreteDeclRef macroRef = resolveConcreteDeclRef(macro, locator);
29402940
auto expansion = new (ctx) MacroExpansionExpr(
2941-
dc, expr->getStartLoc(), DeclNameRef(macro->getName()),
2942-
DeclNameLoc(expr->getLoc()), SourceLoc(), {}, SourceLoc(), nullptr,
2943-
MacroRole::Expression, /*isImplicit=*/true, expandedType);
2941+
dc, expr->getStartLoc(), DeclNameRef(), DeclNameLoc(),
2942+
DeclNameRef(macro->getName()), DeclNameLoc(expr->getLoc()),
2943+
SourceLoc(), {}, SourceLoc(), nullptr, MacroRole::Expression,
2944+
/*isImplicit=*/true, expandedType);
29442945
expansion->setMacroRef(macroRef);
29452946
(void)evaluateOrDefault(
29462947
ctx.evaluator, ExpandMacroExpansionExprRequest{expansion}, None);

‎lib/Sema/CSGen.cpp

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1227,7 +1227,8 @@ namespace {
12271227

12281228
auto macroIdent = ctx.getIdentifier(kind);
12291229
auto macros = lookupMacros(
1230-
macroIdent, expr->getLoc(), FunctionRefKind::Unapplied,
1230+
Identifier(), macroIdent, expr->getLoc(),
1231+
FunctionRefKind::Unapplied,
12311232
MacroRole::Expression);
12321233
if (!macros.empty()) {
12331234
// Introduce an overload set for the macro reference.
@@ -3886,12 +3887,12 @@ namespace {
38863887

38873888
/// Lookup all macros with the given macro name.
38883889
SmallVector<OverloadChoice, 1>
3889-
lookupMacros(Identifier macroName, SourceLoc loc,
3890+
lookupMacros(Identifier moduleName, Identifier macroName, SourceLoc loc,
38903891
FunctionRefKind functionRefKind,
38913892
MacroRoles roles) {
38923893
SmallVector<OverloadChoice, 1> choices;
38933894
auto results = TypeChecker::lookupMacros(
3894-
CurDC, DeclNameRef(macroName), loc, roles);
3895+
CurDC, DeclNameRef(moduleName), DeclNameRef(macroName), loc, roles);
38953896
for (const auto &result : results) {
38963897
OverloadChoice choice = OverloadChoice(Type(), result, functionRefKind);
38973898
choices.push_back(choice);
@@ -3913,10 +3914,11 @@ namespace {
39133914
CS.associateArgumentList(locator, expr->getArgs());
39143915

39153916
// Look up the macros with this name.
3917+
auto moduleIdent = expr->getModuleName().getBaseIdentifier();
39163918
auto macroIdent = expr->getMacroName().getBaseIdentifier();
39173919
FunctionRefKind functionRefKind = FunctionRefKind::SingleApply;
39183920
auto macros = lookupMacros(
3919-
macroIdent, expr->getMacroNameLoc().getBaseNameLoc(),
3921+
moduleIdent, macroIdent, expr->getMacroNameLoc().getBaseNameLoc(),
39203922
functionRefKind, expr->getMacroRoles());
39213923
if (macros.empty()) {
39223924
ctx.Diags.diagnose(expr->getMacroNameLoc(), diag::macro_undefined,

‎lib/Sema/TypeCheckDecl.cpp

Lines changed: 36 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1606,25 +1606,53 @@ TypeChecker::lookupPrecedenceGroup(DeclContext *dc, Identifier name,
16061606
return PrecedenceGroupLookupResult(dc, name, std::move(groups));
16071607
}
16081608

1609-
SmallVector<MacroDecl *, 1>
1610-
TypeChecker::lookupMacros(DeclContext *dc, DeclNameRef macroName,
1611-
SourceLoc loc, MacroRoles roles) {
1609+
SmallVector<MacroDecl *, 1> TypeChecker::lookupMacros(DeclContext *dc,
1610+
DeclNameRef moduleName,
1611+
DeclNameRef macroName,
1612+
SourceLoc loc,
1613+
MacroRoles roles) {
16121614
SmallVector<MacroDecl *, 1> choices;
16131615
auto moduleScopeDC = dc->getModuleScopeContext();
16141616
ASTContext &ctx = moduleScopeDC->getASTContext();
1615-
UnqualifiedLookupDescriptor descriptor(macroName, moduleScopeDC);
1616-
auto lookup = evaluateOrDefault(
1617-
ctx.evaluator, UnqualifiedLookupRequest{descriptor}, {});
1618-
for (const auto &found : lookup.allResults()) {
1619-
if (auto macro = dyn_cast<MacroDecl>(found.getValueDecl())) {
1617+
1618+
auto addChoiceIfApplicable = [&](ValueDecl *decl) {
1619+
if (auto macro = dyn_cast<MacroDecl>(decl)) {
16201620
auto candidateRoles = macro->getMacroRoles();
16211621
if ((candidateRoles && roles.contains(candidateRoles)) ||
16221622
// FIXME: `externalMacro` should have all roles.
16231623
macro->getBaseIdentifier().str() == "externalMacro") {
16241624
choices.push_back(macro);
16251625
}
16261626
}
1627+
};
1628+
1629+
// When a module is specified, it's a module-qualified lookup.
1630+
if (moduleName) {
1631+
UnqualifiedLookupDescriptor moduleLookupDesc(
1632+
moduleName, moduleScopeDC, SourceLoc(),
1633+
UnqualifiedLookupFlags::TypeLookup);
1634+
auto moduleLookup = evaluateOrDefault(
1635+
ctx.evaluator, UnqualifiedLookupRequest{moduleLookupDesc}, {});
1636+
auto foundTypeDecl = moduleLookup.getSingleTypeResult();
1637+
auto *moduleDecl = dyn_cast_or_null<ModuleDecl>(foundTypeDecl);
1638+
if (!moduleDecl)
1639+
return {};
1640+
1641+
ModuleQualifiedLookupRequest req{
1642+
moduleScopeDC, moduleDecl, macroName, NL_ExcludeMacroExpansions};
1643+
auto lookup = evaluateOrDefault(ctx.evaluator, req, {});
1644+
for (auto *found : lookup)
1645+
addChoiceIfApplicable(found);
1646+
}
1647+
// Otherwise it's an unqualified lookup.
1648+
else {
1649+
UnqualifiedLookupDescriptor descriptor(macroName, moduleScopeDC);
1650+
auto lookup = evaluateOrDefault(
1651+
ctx.evaluator, UnqualifiedLookupRequest{descriptor}, {});
1652+
for (const auto &found : lookup.allResults())
1653+
addChoiceIfApplicable(found.getValueDecl());
16271654
}
1655+
16281656
return choices;
16291657
}
16301658

‎lib/Sema/TypeCheckMacros.cpp

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1527,7 +1527,8 @@ ConcreteDeclRef ResolveMacroRequest::evaluate(Evaluator &evaluator,
15271527
// So bail out to prevent diagnostics from the contraint system.
15281528
if (macroRef.getAttr()) {
15291529
auto foundMacros = TypeChecker::lookupMacros(
1530-
dc, macroRef.getMacroName(), SourceLoc(), roles);
1530+
dc, macroRef.getModuleName(), macroRef.getMacroName(),
1531+
SourceLoc(), roles);
15311532
if (foundMacros.empty())
15321533
return ConcreteDeclRef();
15331534
}
@@ -1543,7 +1544,8 @@ ConcreteDeclRef ResolveMacroRequest::evaluate(Evaluator &evaluator,
15431544
} else {
15441545
SourceRange genericArgsRange = macroRef.getGenericArgsRange();
15451546
macroExpansion = new (ctx) MacroExpansionExpr(
1546-
dc, macroRef.getSigilLoc(), macroRef.getMacroName(),
1547+
dc, macroRef.getSigilLoc(), macroRef.getModuleName(),
1548+
macroRef.getModuleNameLoc(), macroRef.getMacroName(),
15471549
macroRef.getMacroNameLoc(), genericArgsRange.Start,
15481550
macroRef.getGenericArgs(), genericArgsRange.End,
15491551
macroRef.getArgs(), roles);

0 commit comments

Comments
 (0)