Syntactic macro system #969
Merged
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
@swift-ci please test |
1 similar comment
|
@swift-ci please test |
Use expand-macros to see the effect of expanding all uses of example macros within the given source file, and emitting and diagnostics they produce.
Instead, have `#line` create the more general `MacroExpansionExprSyntax` node.
The general macro production works. We can't implement this as a macro just yet, though.
Stop creating `PoundFunctionSyntaxExpr` nodes in the parser. Implement a macro version instead.
…eral` Remove the "object literal" parsing grammar entirely, sending `#colorLiteral`, `#fileLiteral`, and `#imageLiteral` through the normal macro-expansion expressions. Implement `FileLiteral` and `ImageLiteral` macros in the example macro system.
All of these are subsumed by macro expansion expressions.
DougGregor
force-pushed
the
syntactic-macro-system
branch
from
693c500 to
5c02eb5
Compare
|
@swift-ci please test |
|
The refactoring here to generalize the parsing of # expressions is quite valuable to simplify the syntax tree. Merging! |
allevato
added a commit
to allevato/swift-format
that referenced
this pull request
Oct 19, 2022
This gets swift-format building/tests passing again after the following changes: swiftlang/swift-syntax#963 (Allow postfix #if to be empty) swiftlang/swift-syntax#969 (Syntactic macro system)
ahoppen
reviewed
Oct 19, 2022
| } | ||
|
|
||
| // Parse the optional trailing closures. | ||
| let trailingClosure: RawClosureExprSyntax? |
There was a problem hiding this comment.
How would a macro expansion declaration with a trailing closure look like?
| let (unexpectedBeforeMacro, macro) = self.expectIdentifier() | ||
|
|
||
| // Parse the optional parenthesized argument list. | ||
| let leftParen = self.consume(if: .leftParen, where: { !$0.isAtStartOfLine }) |
There was a problem hiding this comment.
AFAICT parseMacroExpansionExpr and parseMacroExpansionDecl seem pretty similar to me. Do you think we could unify their parsing?
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Implement a simple, experimental syntactic macro system that allows syntax of the form
#macroName(optional-macro-args)to be treated as a macro evaluation, where macros are implemented via syntactic transformations on aSwiftSyntaxtree.There are a few example macros here, one of which is a
stringifymacro that expands its argument into a tuple containing both the value and the string form of the argument, e.g.,will evaluate to
New macros can be introduced by creating a type conforming to one of the
*Macroprotocols, such as theExpressionMacroprotocol for types that use the#expression syntax.Although this library provides purely syntactic expansion, the idea is to have a semantic component to macros, such that Swift's type checker performs some checking on the macro arguments, then initiates the macro evaluation to produce the final code.
The design here is discussed in A Possible Vision for Macros in Swift.