1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
//===--- Bridging/PatternBridging.cpp -------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2022-2024 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
#include "swift/AST/ASTBridging.h"
#include "swift/AST/ASTContext.h"
#include "swift/AST/Expr.h"
#include "swift/AST/Identifier.h"
#include "swift/AST/Pattern.h"
#include "swift/AST/TypeRepr.h"
#include "swift/Basic/Assertions.h"
using namespace swift;
//===----------------------------------------------------------------------===//
// MARK: Patterns
//===----------------------------------------------------------------------===//
// Define `.asPattern` on each BridgedXXXPattern type.
#define PATTERN(Id, Parent) \
BridgedPattern Bridged##Id##Pattern_asPattern( \
Bridged##Id##Pattern pattern) { \
return static_cast<Pattern *>(pattern.unbridged()); \
}
#include "swift/AST/PatternNodes.def"
BridgedNullableVarDecl BridgedPattern_getSingleVar(BridgedPattern cPattern) {
return cPattern.unbridged()->getSingleVar();
}
BridgedAnyPattern BridgedAnyPattern_createParsed(BridgedASTContext cContext,
BridgedSourceLoc cLoc) {
return new (cContext.unbridged()) AnyPattern(cLoc.unbridged());
}
BridgedAnyPattern BridgedAnyPattern_createImplicit(BridgedASTContext cContext) {
return AnyPattern::createImplicit(cContext.unbridged());
}
BridgedBindingPattern
BridgedBindingPattern_createParsed(BridgedASTContext cContext,
BridgedSourceLoc cKeywordLoc, bool isLet,
BridgedPattern cSubPattern) {
VarDecl::Introducer introducer =
isLet ? VarDecl::Introducer::Let : VarDecl::Introducer::Var;
return BindingPattern::createParsed(cContext.unbridged(),
cKeywordLoc.unbridged(), introducer,
cSubPattern.unbridged());
}
BridgedBindingPattern
BridgedBindingPattern_createImplicitCatch(BridgedDeclContext cDeclContext,
BridgedSourceLoc cLoc) {
return BindingPattern::createImplicitCatch(cDeclContext.unbridged(),
cLoc.unbridged());
}
BridgedExprPattern
BridgedExprPattern_createParsed(BridgedDeclContext cDeclContext,
BridgedExpr cExpr) {
auto *DC = cDeclContext.unbridged();
auto &context = DC->getASTContext();
return ExprPattern::createParsed(context, cExpr.unbridged(), DC);
}
BridgedIsPattern BridgedIsPattern_createParsed(BridgedASTContext cContext,
BridgedSourceLoc cIsLoc,
BridgedTypeExpr cTypeExpr) {
return new (cContext.unbridged())
IsPattern(cIsLoc.unbridged(), cTypeExpr.unbridged(),
/*subPattern=*/nullptr, CheckedCastKind::Unresolved);
}
BridgedNamedPattern
BridgedNamedPattern_createParsed(BridgedASTContext cContext,
BridgedDeclContext cDeclContext,
BridgedIdentifier name, BridgedSourceLoc loc) {
auto &context = cContext.unbridged();
auto *dc = cDeclContext.unbridged();
// Note 'isStatic' and the introducer value are temporary.
// The outer context should set the correct values.
auto *varDecl = new (context) VarDecl(
/*isStatic=*/false, VarDecl::Introducer::Let, loc.unbridged(),
name.unbridged(), dc);
auto *pattern = new (context) NamedPattern(varDecl);
return pattern;
}
BridgedParenPattern BridgedParenPattern_createParsed(
BridgedASTContext cContext, BridgedSourceLoc cLParenLoc,
BridgedPattern cSubPattern, BridgedSourceLoc cRParenLoc) {
return new (cContext.unbridged()) ParenPattern(
cLParenLoc.unbridged(), cSubPattern.unbridged(), cRParenLoc.unbridged());
}
BridgedTuplePattern BridgedTuplePattern_createParsed(
BridgedASTContext cContext, BridgedSourceLoc cLParenLoc,
BridgedArrayRef cElements, BridgedSourceLoc cRParenLoc) {
ASTContext &context = cContext.unbridged();
llvm::SmallVector<TuplePatternElt, 4> elements;
elements.reserve(cElements.Length);
llvm::transform(cElements.unbridged<BridgedTuplePatternElt>(),
std::back_inserter(elements),
[](const BridgedTuplePatternElt &elt) {
return TuplePatternElt(elt.Label.unbridged(),
elt.LabelLoc.unbridged(),
elt.ThePattern.unbridged());
});
return TuplePattern::create(context, cLParenLoc.unbridged(), elements,
cRParenLoc.unbridged());
}
BridgedTypedPattern BridgedTypedPattern_createParsed(BridgedASTContext cContext,
BridgedPattern cPattern,
BridgedTypeRepr cType) {
return new (cContext.unbridged())
TypedPattern(cPattern.unbridged(), cType.unbridged());
}
BridgedTypedPattern
BridgedTypedPattern_createPropagated(BridgedASTContext cContext,
BridgedPattern cPattern,
BridgedTypeRepr cType) {
return TypedPattern::createPropagated(
cContext.unbridged(), cPattern.unbridged(), cType.unbridged());
}
void BridgedPattern_setImplicit(BridgedPattern cPattern) {
cPattern.unbridged()->setImplicit();
}
BridgedIdentifier BridgedPattern_getBoundName(BridgedPattern cPattern) {
return cPattern.unbridged()->getBoundName();
}
|
