Changelog

Note: This is in reverse chronological order, so newer entries are added to the top.

`main`

With the introduction of the new SwiftParser, the existing SwiftSyntaxParser is deprecated and will be removed. The module and it's API surface still exists as a thin wrapper over SwiftParser, which no longer requires a matching toolchain or _InternalSwiftSyntaxParser shared library to work.

Swift 5.6

To clarify that the edits passed to IncrementalParseTransition are applied concurrently, introduce a new ConcurrentEdit type that provides the guarantee and allows translation of sequentially applied edits to the expected concurrent form.
The SwiftSyntaxParser type and a few related types now live in their own module (also named SwiftSyntaxParser). This allows using SwiftSyntax for code generation purposes without having a compatible _InternalSwiftSyntaxParser.dylib around.

import SwiftSyntaxParser where necessary.
DiagnosticEngine has been removed. Instead, SyntaxParser takes a closure through which it emits parser diagnostics. Depending on your needs, use the closure to handle the diagnostics or write + hook up your own diagnostics engine.

Swift 5.3

Introduced FunctionCallExprSyntax.additionalTrailingClosures property with type MultipleTrailingClosureElementListSyntax? for supporting SE-0279 Multiple Trailing Closures.
Introduced syntaxNodeType property for all types conforming to SyntaxProtocol, which returns the underlying syntax node type. It is primarily intended as a debugging aid during development.
Provided a clearer error message for the "parser compatibility" error.

Swift 5.2

ReversedSyntaxChildren has been removed

Use the reversed() property on SyntaxCollection, which now conforms to BidirectionalCollection instead.
SyntaxCollections now conform to BidirectionalCollection

The previous conformance to Sequence has been upgraded to a conformance to BidirectionalCollection
Properties isExpr, isDecl, isStmt, isType and isPattern removed from SyntaxNode

Use is(ExprSyntaxProtocol.self) etc. instead.
Property uniqueIdentifier removed from syntax nodes and SyntaxNode

Use the newly added property id or the conformance to Identifiable instead.
Syntax nodes and SyntaxNode conform to Identifiable

Identifiable conformance has been added to all syntax nodes and the SyntaxNode type using SyntaxIdentifier as the identifier.
The walk method on syntax nodes has been removed.

Instead, use the walk method on the SyntaxVisitor.
```
// Before 
tree.walk(&visitor)

// Now
visitor.walk(tree)
```
SyntaxVisitor and SyntaxAnyVisitor are a class and no longer a protocol.

For performance reasons the SyntaxVisitor and SyntaxAnyVisitor were migrated from being a protocol to being a class.

Any structs conforming to the above protocols need to become classes. Implementing methods need to be marked override and, if necessary, any mutating keywords need to be removed.
```
// Before
struct Visitor: SyntaxVisitor {
  mutating func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {
    /* ... */
  }
}

// Now
class Visitor: SyntaxVisitor {
  override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {
    /* ... */
  }
}
```
A new type SyntaxEnum has been introduced

The new type SyntaxEnum allow exhaustive switching over all syntax types. It can be constructed by calling asSyntaxEnum on Syntax.
```
let node: Syntax

switch node.as(SyntaxEnum.self) {
  case .identifierExpr(let identifierExprSyntax):
  /* ... */
}
```

Modelling syntax nodes as structs

For increased performance, the modelling of the syntax node hierarchy has been switched from being protocol-based to being struct-based. This includes the following changes:

The protocols ExprSyntax, DeclSyntax, Syntax etc. have been removed

For passing values of these types around, use the new type erasers ExprSyntax, DeclSyntax, Syntax etc. instead. To add computed properties or functions to all expression nodes, write an extension on ExprSyntaxProtocol. To add methods to all syntax nodes, extend SyntaxProtcol.

Pass type eraser
```
func foo(_ expr: ExprSyntax) {}
```
stays the same. ExprSyntax is now a struct and not a protocol. See below on how to create an ExprSyntax.

Extending a type
```
// Before
extension ExprSyntax {
  func evaluateAsIntegerExpr() -> Int { /* ... */ }
}

// Now
extension ExprSyntaxProtocol {
  func evaluateAsIntegerExpr() -> Int { /* ... */ }
}
```
Checking a node's type can no longer be performed using the is operator. Use the is(_: SyntaxProtocol) method on any type eraser instead.
```
// Before 
exprSyntax is IdentifierExprSyntax

// Now
exprSyntax.is(IdentifierExprSyntax.self)
```

To retrieve the non-type erased version of a type, use the as(_: SyntaxProtocol.self) method

let identifierExprSyntax: IdentifierExprSyntax = /* ... */
let node = Syntax(identifierExprSyntax)
node.asProtocol(SyntaxProtocol.self) // returns an IdentifierExprSyntax with static type SyntaxProtocol
node.asProtocol(ExprSyntaxProtocol.self) // returns an IdentifierExprSyntax with static type ExprSyntaxProtocol?

Downcasting can no longer be performed using the as operator. For downcasting use the as(_: SyntaxProtocol) method on any type eraser.
```
// Before
exprSyntax as? IdentifierExprSyntax

// Now
exprSyntax.as(IdentifierExprSyntax.self)
```

Upcasting needs to be performed explicitly. Use the designated initializers for this.

// Before
func foo() -> ExprSyntax {
  /* ... */
  return identiferExprSyntax
}

// Now
func foo() -> ExprSyntax {
  /* ... */
  return ExprSyntax(identiferExprSyntax)
}