codeimage.io

STUDIO HAZE · image

Topaz source

Open by house policy. Topaz is our own language.

Topaz 5.21 · 113 files

topaz/src/printers/javascript.tpz

Topaz · 118825 B · Original file

1// JavaScript and TypeScript printing machine: the node printers and the iterative
2// driver that computes each child piece they request.
4import nodes { 노드종류 }
5import print { 글자합치기, 인쇄글조각, 인쇄조각같음, 인쇄조각이음, 인쇄조각자름, 인쇄조각접미, 인쇄호출 }
6import printer_state { 댓글고정있음, 식별자이름, 인쇄글조각결과, 인쇄조각결과합치기, 자식순번, 자식순번들, 준비된인쇄상태 }
7import printers.javascript.comments { 댓글붙이기조각 }
8import printers.javascript.layout {
9 가장자리접두,
10 노드들여쓰기,
11 리터럴닫기접두,
12 리터럴사이접두,
13 리터럴열,
14 리터럴첫줄수,
15 매개기준끝행,
16 매개뒤형식접두,
17 명세닫기공백,
18 모듈출처접두,
19 문장부족행,
20 문장접두,
21 블록닫기접두,
22 유효시작행,
23 절접두,
24 조각끝행,
25 줄접두,
26 직접앞끝행,
27 함수몸접두,
28 호출대상끝행,
29 화살표괄호생략인가,
30 화살표머리첫잎이매개인가,
32import printers.javascript.literals { 철자문자열리터럴 }
33import printers.javascript.precedence { 우선순위, 인괄호필요, 인머리끄기, 인머리내림, 인머리켜기 }
34import printers.javascript.store { 인쇄글결과조각, 인쇄기계저장쓰기, 인쇄기계저장조각읽기 }
35import schema { 들여쓰기 }
36import structure { 구조노드, 구조스칼라, 구조입력, 노드스칼라, 스칼라논리, 스칼라문자, 스칼라있음, 스칼라정수 }
37import types { 인쇄조각판 }
39function 들사이조각인쇄(준비: 준비된인쇄상태, 순번들: Array<int>, 깊이: int, 사이: string) -> Result<int, string> {
40 let mut 합 = 0; let mut 색인 = 0
41 while 색인 < 순번들.length {
42 if 색인 > 0 { 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 사이)) }
43 합 = 인쇄조각이음(준비.조각판, 합, 순번인쇄조각(준비, 순번들[색인], 깊이)?)
44 색인 = 색인 + 1
45 }
46 Ok(합)
49// A named import/export clause prints `{`, its specifier list, then `}` as a
50// plain token, so the brace stays on the last specifier's row; the space before
51// it is suppressed exactly when the last specifier carries the clause's
52// trailing comma, because the reference printer drops the queued space that
53// follows a structural trailing comma. The list's own rows and columns come
54// from the one edge primitive, like every other edge.
55function 명세들조각인쇄(
56 준비: 준비된인쇄상태,
57 순번들: Array<int>,
58 깊이: int
59) -> Result<int, string> {
60 let mut 합 = 0
61 let mut 색인 = 0
62 while 색인 < 순번들.length {
63 if 색인 > 0 {
64 합 = 인쇄조각이음(
65 준비.조각판,
66 합,
67 인쇄글조각(준비.조각판, "," + 가장자리접두(준비, 순번들[색인], " "))
68 )
69 }
70 합 = 인쇄조각이음(준비.조각판, 합, 순번인쇄조각(준비, 순번들[색인], 깊이)?)
71 색인 = 색인 + 1
72 }
73 Ok(합)
76function 형식목록조각인쇄(
77 준비: 준비된인쇄상태,
78 부모순번: int,
79 순번들: Array<int>,
80 깊이: int
81) -> Result<int, string> {
82 if !준비.오프셋배치 || 순번들.length == 0 {
83 return 들사이조각인쇄(준비, 순번들, 깊이, ", ")
84 }
85 let 부모 = 준비.구조.노드들[부모순번]
86 let mut 합 = 0
87 let mut 색인 = 0
88 while 색인 < 순번들.length {
89 let 현재 = 준비.구조.노드들[순번들[색인]]
90 if 색인 == 0 {
91 let 줄수 = 스칼라정수(현재, "startRow") - 스칼라정수(부모, "startRow")
92 if 줄수 > 0 {
93 합 = 인쇄조각이음(
94 준비.조각판, 합,
95 인쇄글조각(준비.조각판, 줄접두(줄수, 노드들여쓰기(준비, 순번들[색인])))
96 )
97 }
98 } else {
99 let 이전 = 준비.구조.노드들[순번들[색인 - 1]]
100 let 줄수 = 스칼라정수(현재, "startRow") - 스칼라정수(이전, "endRow")
101 let 사이 = if 줄수 > 0 {
102 "," + 줄접두(줄수, 노드들여쓰기(준비, 순번들[색인]))
103 } else { ", " }
104 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 사이))
105 }
106 합 = 인쇄조각이음(
107 준비.조각판, 합, 순번인쇄조각(준비, 순번들[색인], 깊이)?
108 )
109 색인 = 색인 + 1
110 }
111 Ok(합)
114function 매개들조각인쇄(
115 준비: 준비된인쇄상태,
116 부모순번: int,
117 순번들: Array<int>,
118 깊이: int
119) -> Result<int, string> {
120 if !준비.오프셋배치 || 순번들.length == 0 {
121 return 들사이조각인쇄(준비, 순번들, 깊이, ", ")
122 }
123 let 들여쓰기값 = 노드들여쓰기(준비, 부모순번)
124 let 기준끝행 = 매개기준끝행(준비, 부모순번)
125 let mut 합 = 0
126 let mut 색인 = 0
127 while 색인 < 순번들.length {
128 let 현재 = 준비.구조.노드들[순번들[색인]]
129 if 색인 == 0 {
130 let 줄수 = 스칼라정수(현재, "startRow") - 기준끝행
131 if 줄수 > 0 {
132 합 = 인쇄조각이음(
133 준비.조각판,
134 합,
135 인쇄글조각(준비.조각판, 줄접두(줄수, 들여쓰기값))
136 )
137 }
138 } else {
139 let 이전 = 준비.구조.노드들[순번들[색인 - 1]]
140 let 줄수 = 스칼라정수(현재, "startRow") - 스칼라정수(이전, "endRow")
141 let 사이 = if 줄수 > 0 { "," + 줄접두(줄수, 들여쓰기값) } else { ", " }
142 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 사이))
143 }
144 합 = 인쇄조각이음(
145 준비.조각판,
146 합,
147 순번인쇄조각(준비, 순번들[색인], 깊이)?
148 )
149 색인 = 색인 + 1
150 }
151 Ok(합)
154function 순번인쇄조각계산(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {
155 let mut 장식들 = 자식순번들(준비, 순번, "decorators")
156 let 종류 = 노드종류(준비.언어번호, 준비.구조.노드들[순번].코드워드)
157 let mut 장식소유자 = 순번
158 if 장식들.length == 0 && 종류 == 306 {
159 let 왼 = 자식순번(준비, 순번, "left")
160 if 왼 >= 0 {
161 장식들 = 자식순번들(준비, 왼, "decorators")
162 장식소유자 = 왼
163 }
164 }
165 let mut 합 = 0
166 let mut 장식색인 = 0
167 while 장식색인 < 장식들.length {
168 let 장식 = 장식들[장식색인]
169 match 순번인쇄조각(준비, 장식, 깊이) {
170 case Ok(조각) => {
171 합 = 인쇄조각이음(준비.조각판, 합, 조각)
172 let mut 다음행 = 스칼라정수(준비.구조.노드들[순번], "startRow")
173 if 장식색인 + 1 < 장식들.length {
174 다음행 = 스칼라정수(준비.구조.노드들[장식들[장식색인 + 1]], "startRow")
175 } else if 종류 != 601 && 종류 != 602 {
176 let mut 다음시작 = 준비.구조.노드들[장식소유자].끝 + 1
177 for 후보 in 준비.구조.노드들 {
178 if 후보.부모순번 == 장식소유자 && 후보.자식필드 != "decorators" &&
179 후보.시작 < 다음시작 {
180 다음시작 = 후보.시작
181 다음행 = 스칼라정수(후보, "startRow")
182 }
183 }
184 }
185 let 줄수 = 다음행 -
186 스칼라정수(준비.구조.노드들[장식], "endRow")
187 합 = 인쇄조각이음(
188 준비.조각판,
189 합,
190 인쇄글조각(
191 준비.조각판,
192 if 준비.오프셋배치 && 줄수 > 0 {
193 줄접두(줄수, 노드들여쓰기(준비, 순번))
194 } else if 준비.오프셋배치 { " " }
195 else { "\n" + 들여쓰기(깊이) }
196 )
197 )
198 }
199 case Err(오류) => return Err(오류)
200 }
201 장식색인 = 장식색인 + 1
202 }
203 let mut 몸 = if 댓글고정있음(준비) { 댓글노드인쇄조각(준비, 순번, 깊이)? }
204 else { 노드인쇄조각(준비, 순번, 깊이)? }
205 let 노드 = 준비.구조.노드들[순번]
206 let 부모종류 = if 노드.부모순번 < 0 { 0 }
207 else { 노드종류(준비.언어번호, 준비.구조.노드들[노드.부모순번].코드워드) }
208 let 부모연산 = if 노드.부모순번 < 0 { "" }
209 else { 스칼라문자(준비.구조.노드들[노드.부모순번], "operator") }
210 // The v4 spelling scalar is the exact number of explicit parenthesis groups
211 // on every expression kind. Apply all of them here; precedence printing
212 // below suppresses its synthetic group when an explicit group already does
213 // that job, so nested binary groups are neither dropped nor duplicated.
214 let 괄호수 = 스칼라정수(노드, "spelling.parentheses")
215 if 괄호수 > 0 {
216 let mut 열기 = ""
217 let mut 닫기 = ""
218 let mut 괄호 = 0
219 while 괄호 < 괄호수 {
220 열기 = 열기 + "("
221 닫기 = 닫기 + ")"
222 괄호 = 괄호 + 1
223 }
224 let 앞끝행 = if 노드.부모순번 < 0 { 스칼라정수(노드, "startRow") }
225 else { 직접앞끝행(준비, 노드.부모순번, 순번) }
226 let 안쪽줄수 = 스칼라정수(노드, "startRow") - 앞끝행
227 몸 = 인쇄조각결과합치기(준비, [
228 인쇄글조각결과(준비, 열기 + if 준비.오프셋배치 && 안쪽줄수 > 0 {
229 줄접두(안쪽줄수, 노드들여쓰기(준비, 순번))
230 } else { "" }),
231 Ok(몸), 인쇄글조각결과(준비, 닫기)
232 ])?
233 }
234 if 스칼라논리(준비.구조.노드들[순번], "spelling.trailingComma") {
235 몸 = 인쇄조각결과합치기(준비, [Ok(몸), 인쇄글조각결과(준비, ",")])?
236 }
237 Ok(인쇄조각이음(준비.조각판, 합, 몸))
240function 자식조각인쇄(준비: 준비된인쇄상태, 부모: int, 필드: string, 깊이: int) -> Result<int, string> {
241 let 순번 = 자식순번(준비, 부모, 필드)
242 if 순번 < 0 { Ok(0) }
243 else { 순번인쇄조각(준비, 순번, 깊이) }
246// The same single child, printed through the one edge primitive: the caller
247// gives the spelling this edge takes when parent and child share a row, and the
248// primitive decides whether that spelling or the carried row break is what the
249// edge prints.
250function 자식조각인쇄접두(
251 준비: 준비된인쇄상태,
252 부모: int,
253 필드: string,
254 깊이: int,
255 같은행: string
256) -> Result<int, string> {
257 let 순번 = 자식순번(준비, 부모, 필드)
258 if 순번 < 0 { return Ok(0) }
259 인쇄조각결과합치기(준비, [
260 인쇄글조각결과(준비, 가장자리접두(준비, 순번, 같은행)),
261 순번인쇄조각(준비, 순번, 깊이)
262 ])
265function 문장목록조각인쇄(준비: 준비된인쇄상태, 순번들: Array<int>, 깊이: int) -> Result<int, string> {
266 let mut 합 = 0; let mut 색인 = 0
267 let mut 이전부족행 = 0
268 while 색인 < 순번들.length {
269 if 준비.오프셋배치 {
270 합 = 인쇄조각이음(
271 준비.조각판, 합,
272 인쇄글조각(준비.조각판, 문장접두(준비, 순번들, 색인, 이전부족행))
273 )
274 } else {
275 if 색인 > 0 { 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "\n")) }
276 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 들여쓰기(깊이)))
277 }
278 let 문장조각 = 순번인쇄조각(준비, 순번들[색인], 깊이)?
279 합 = 인쇄조각이음(준비.조각판, 합, 문장조각)
280 이전부족행 = if 준비.오프셋배치 {
281 문장부족행(준비, 순번들[색인], 문장조각)
282 } else { 0 }
283 색인 = 색인 + 1
284 }
285 Ok(합)
288function 문장블록조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int, 머리: string) -> Result<int, string> {
289 let 지시들 = 자식순번들(준비, 순번, "directives")
290 let 본문들 = 자식순번들(준비, 순번, "body")
291 if 지시들.length == 0 && 본문들.length == 0 {
292 if 준비.오프셋배치 {
293 let 노드 = 준비.구조.노드들[순번]
294 let 줄수 = 스칼라정수(노드, "endRow") - 스칼라정수(노드, "startRow")
295 if 줄수 > 0 {
296 let 닫기공백 = 노드들여쓰기(준비, 순번)
297 return 인쇄글조각결과(준비, 머리 + "\{" + 줄접두(줄수, 닫기공백) + "\}")
298 }
299 }
300 return 인쇄글조각결과(준비, 머리 + "\{\}")
301 }
302 if 준비.오프셋배치 {
303 let mut 내용들: Array<int> = []
304 for 지시 in 지시들 { 내용들.push(지시) }
305 for 본문 in 본문들 { 내용들.push(본문) }
306 let 내용조각 = 문장목록조각인쇄(준비, 내용들, 깊이 + 1)?
307 let 마지막부족행 = if 내용들.length == 0 { 0 } else {
308 문장부족행(
309 준비,
310 내용들[내용들.length - 1],
311 순번인쇄조각(준비, 내용들[내용들.length - 1], 깊이 + 1)?
312 )
313 }
314 return 인쇄조각결과합치기(준비, [
315 인쇄글조각결과(준비, 머리 + "\{"),
316 Ok(내용조각),
317 인쇄글조각결과(준비, 블록닫기접두(준비, 순번, 내용들, 마지막부족행) + "\}")
318 ])
319 }
320 인쇄조각결과합치기(준비, [
321 인쇄글조각결과(준비, 머리 + "\{\n"),
322 문장목록조각인쇄(준비, 지시들, 깊이 + 1),
323 인쇄글조각결과(준비, if 지시들.length > 0 && 본문들.length > 0 { "\n\n" } else { "" }),
324 문장목록조각인쇄(준비, 본문들, 깊이 + 1),
325 인쇄글조각결과(준비, "\n" + 들여쓰기(깊이) + "\}")
326 ])
329function 하위식조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int, 최소: int) -> Result<int, string> {
330 let 명시괄호 = 스칼라정수(준비.구조.노드들[순번], "spelling.parentheses") > 0
331 let 정밀괄호 = !명시괄호 && 우선순위(준비, 순번) < 최소
332 if 정밀괄호 { 인머리끄기(준비, 순번) }
333 let 인괄호 = !명시괄호 && !정밀괄호 && 인괄호필요(준비, 순번)
334 let 식 = 순번인쇄조각(준비, 순번, 깊이)?
335 if 정밀괄호 || 인괄호 {
336 return 인쇄조각결과합치기(준비, [
337 인쇄글조각결과(준비, "("), Ok(식), 인쇄글조각결과(준비, ")")
338 ])
339 }
340 Ok(식)
343function 하위식들조각인쇄(
344 준비: 준비된인쇄상태,
345 순번들: Array<int>,
346 깊이: int,
347 최소: int
348) -> Result<int, string> {
349 let mut 합 = 0
350 let mut 색인 = 0
351 while 색인 < 순번들.length {
352 if 색인 > 0 {
353 합 = 인쇄조각이음(
354 준비.조각판,
355 합,
356 인쇄글조각(준비.조각판, "," + 가장자리접두(준비, 순번들[색인], " "))
357 )
358 }
359 합 = 인쇄조각이음(
360 준비.조각판,
361 합,
362 하위식조각인쇄(준비, 순번들[색인], 깊이, 최소)?
363 )
364 색인 = 색인 + 1
365 }
366 Ok(합)
369function 호출인수들조각인쇄(
370 준비: 준비된인쇄상태,
371 부모순번: int,
372 순번들: Array<int>,
373 깊이: int,
374 최소: int
375) -> Result<int, string> {
376 if !준비.오프셋배치 {
377 return 하위식들조각인쇄(준비, 순번들, 깊이, 최소)
378 }
379 let 부모 = 준비.구조.노드들[부모순번]
380 let 대상순번 = 자식순번(준비, 부모순번, "callee")
381 let 대상끝행 = 호출대상끝행(준비, 부모순번)
382 let mut 대상끝열 = if 대상순번 < 0 { 스칼라정수(부모, "startColumn") }
383 else { 스칼라정수(준비.구조.노드들[대상순번], "endColumn") }
384 let 형식인수 = if 자식순번(준비, 부모순번, "typeArguments") >= 0 {
385 자식순번(준비, 부모순번, "typeArguments")
386 } else { 자식순번(준비, 부모순번, "typeParameters") }
387 if 형식인수 >= 0 {
388 대상끝열 = 스칼라정수(준비.구조.노드들[형식인수], "endColumn")
389 }
390 // The reference printer catches the closing parenthesis up to the call's
391 // carried END row whether or not the list has any arguments.
392 if 순번들.length == 0 {
393 let 빈닫기줄수 = 스칼라정수(부모, "endRow") - 대상끝행
394 if 빈닫기줄수 > 0 {
395 return Ok(인쇄글조각(
396 준비.조각판,
397 줄접두(빈닫기줄수, 노드들여쓰기(준비, 부모순번))
398 ))
399 }
400 return Ok(0)
401 }
402 let 인수들여쓰기 = 노드들여쓰기(준비, 순번들[0])
403 let 첫구분자너비 = if 노드종류(준비.언어번호, 부모.코드워드) == 211 &&
404 스칼라논리(부모, "optional") { 3 } else { 1 }
405 let mut 합 = 0
406 let mut 색인 = 0
407 while 색인 < 순번들.length {
408 let 현재 = 준비.구조.노드들[순번들[색인]]
409 if 색인 == 0 {
410 // An argument the image carries parentheses for takes its row break
411 // inside them, so this edge stays on the callee's row.
412 let 첫줄수 = if 스칼라정수(현재, "spelling.parentheses") > 0 { 0 }
413 else { 유효시작행(준비, 순번들[색인]) - 대상끝행 }
414 if 첫줄수 > 0 {
415 합 = 인쇄조각이음(
416 준비.조각판,
417 합,
418 인쇄글조각(준비.조각판, 줄접두(첫줄수, 인수들여쓰기))
419 )
420 } else {
421 // A first argument whose parameter list prints without parentheses is
422 // reached by the reference printer's bare-arrow branch, which catches
423 // the row up before the delimiter gap can be applied, so the carried
424 // gap is not part of that edge.
425 let mut 공백수 = if 화살표괄호생략인가(준비, 순번들[색인]) { 0 }
426 else {
427 스칼라정수(현재, "startColumn") - 대상끝열 -
428 첫구분자너비 - 스칼라정수(현재, "spelling.parentheses")
429 }
430 let mut 공백 = ""
431 while 공백수 > 0 { 공백 = 공백 + " "; 공백수 = 공백수 - 1 }
432 if 공백 != "" {
433 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 공백))
434 }
435 }
436 } else {
437 let 이전 = 준비.구조.노드들[순번들[색인 - 1]]
438 let 줄수 = 유효시작행(준비, 순번들[색인]) - 스칼라정수(이전, "endRow")
439 let 사이 = if 줄수 > 0 { "," + 줄접두(줄수, 인수들여쓰기) } else { ", " }
440 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 사이))
441 }
442 합 = 인쇄조각이음(
443 준비.조각판,
444 합,
445 하위식조각인쇄(준비, 순번들[색인], 깊이, 최소)?
446 )
447 색인 = 색인 + 1
448 }
449 let 닫기줄수 = 스칼라정수(부모, "endRow") - 조각끝행(준비, 대상끝행, 합)
450 if 닫기줄수 > 0 {
451 합 = 인쇄조각이음(
452 준비.조각판,
453 합,
454 인쇄글조각(준비.조각판, 줄접두(닫기줄수, 노드들여쓰기(준비, 부모순번)))
455 )
456 }
457 Ok(합)
460function 연쇄대상조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int, 연속: bool) -> Result<int, string> {
461 let 종류 = 노드종류(준비.언어번호, 준비.구조.노드들[순번].코드워드)
462 if !연속 && (종류 == 211 || 종류 == 209) &&
463 스칼라정수(준비.구조.노드들[순번], "spelling.parentheses") == 0 {
464 인머리끄기(준비, 순번)
465 return 인쇄조각결과합치기(준비, [
466 인쇄글조각결과(준비, "("),
467 순번인쇄조각(준비, 순번, 깊이),
468 인쇄글조각결과(준비, ")")
469 ])
470 }
471 하위식조각인쇄(준비, 순번, 깊이, 17)
474function 함수머리조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int, 이름있음: bool) -> Result<int, string> {
475 let 노드 = 준비.구조.노드들[순번]
476 let mut 머리 = (if 스칼라논리(노드, "async") { "async " } else { "" }) + "function"
477 if 스칼라논리(노드, "generator") { 머리 = 머리 + "*" }
478 if !이름있음 { 머리 = 머리 + " " }
479 let mut 합 = 인쇄글조각(준비.조각판, 머리)
480 if 이름있음 {
481 합 = 인쇄조각이음(
482 준비.조각판, 합, 자식조각인쇄접두(준비, 순번, "id", 깊이, " ")?
483 )
484 }
485 let 형식매개 = 자식조각인쇄접두(준비, 순번, "typeParameters", 깊이, "")?
486 if 준비.조각판.길이들[형식매개] > 0 {
487 합 = 인쇄조각이음(준비.조각판, 합, 형식매개)
488 }
489 let 매개들 = 자식순번들(준비, 순번, "params")
490 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "("))
491 합 = 인쇄조각이음(
492 준비.조각판,
493 합,
494 매개들조각인쇄(준비, 순번, 매개들, 깊이)?
495 )
496 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, ")"))
497 let 반환 = 자식조각인쇄(준비, 순번, "returnType", 깊이)?
498 if 준비.조각판.길이들[반환] > 0 {
499 합 = 인쇄조각결과합치기(준비, [
500 Ok(합), 인쇄글조각결과(준비, 매개뒤형식접두(준비, 순번, 매개들)), Ok(반환)
501 ])?
502 }
503 Ok(합)
506function 메서드조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {
507 let 노드 = 준비.구조.노드들[순번]
508 let 종류 = 노드종류(준비.언어번호, 노드.코드워드)
509 let mut 머리 = ""
510 if 스칼라논리(노드, "declare") { 머리 = 머리 + "declare " }
511 let 접근 = 스칼라문자(노드, "accessibility")
512 if 접근 != "" { 머리 = 머리 + 접근 + " " }
513 if 스칼라논리(노드, "abstract") { 머리 = 머리 + "abstract " }
514 if 스칼라논리(노드, "static") { 머리 = 머리 + "static " }
515 if 스칼라논리(노드, "override") { 머리 = 머리 + "override " }
516 if 스칼라논리(노드, "async") { 머리 = 머리 + "async " }
517 let 꼴 = 스칼라문자(노드, "kind")
518 if 꼴 == "get" || 꼴 == "set" { 머리 = 머리 + 꼴 + " " }
519 if 스칼라논리(노드, "generator") { 머리 = 머리 + "*" }
520 // The reference printer carries the method's key row across the WHOLE head:
521 // a `get` whose name the source puts on the following row is emitted on the
522 // name's row, not on its own. A decorated member's rows are placed by the
523 // decorator separator, which has already put the printer on the key's row, so
524 // the separator owns the edge there and a second carry would double it.
525 let 계산 = 스칼라논리(노드, "computed")
526 let 키순번 = 자식순번(준비, 순번, "key")
527 let 머리앞 = if 자식순번들(준비, 순번, "decorators").length > 0 { "" }
528 else { 가장자리접두(준비, 키순번, "") }
529 let mut 합 = 인쇄글조각(준비.조각판, 머리앞 + 머리)
530 let 키 = if 계산 && 키순번 >= 0 {
531 하위식조각인쇄(준비, 키순번, 깊이, 2)?
532 } else { 자식조각인쇄(준비, 순번, "key", 깊이)? }
533 if 계산 {
534 합 = 인쇄조각결과합치기(준비, [
535 Ok(합), 인쇄글조각결과(준비, "["), Ok(키), 인쇄글조각결과(준비, "]")
536 ])?
537 } else {
538 합 = 인쇄조각이음(준비.조각판, 합, 키)
539 }
540 if 스칼라논리(노드, "optional") {
541 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "?"))
542 }
543 let 형식매개 = 자식조각인쇄접두(준비, 순번, "typeParameters", 깊이, "")?
544 if 준비.조각판.길이들[형식매개] > 0 {
545 합 = 인쇄조각이음(준비.조각판, 합, 형식매개)
546 }
547 let 매개들 = 자식순번들(준비, 순번, "params")
548 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "("))
549 합 = 인쇄조각이음(
550 준비.조각판,
551 합,
552 매개들조각인쇄(준비, 순번, 매개들, 깊이)?
553 )
554 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, ")"))
555 let 반환 = 자식조각인쇄(준비, 순번, "returnType", 깊이)?
556 if 준비.조각판.길이들[반환] > 0 {
557 합 = 인쇄조각결과합치기(준비, [
558 Ok(합), 인쇄글조각결과(준비, 매개뒤형식접두(준비, 순번, 매개들)), Ok(반환)
559 ])?
560 }
561 let 몸 = 자식조각인쇄(준비, 순번, "body", 깊이)?
562 if 준비.조각판.길이들[몸] > 0 {
563 let 몸순번 = 자식순번(준비, 순번, "body")
564 합 = 인쇄조각결과합치기(준비, [
565 Ok(합), 인쇄글조각결과(준비, 함수몸접두(준비, 순번, 몸순번)), Ok(몸)
566 ])?
567 } else if 종류 == 604 || 종류 == 605 || 종류 == 606 {
568 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, ";"))
569 }
570 Ok(합)
573function 중괄호목록조각인쇄(준비: 준비된인쇄상태, 순번들: Array<int>, 깊이: int, 세미콜론: bool) -> Result<int, string> {
574 if 순번들.length == 0 { return 인쇄글조각결과(준비, "\{\}") }
575 if 준비.오프셋배치 && 세미콜론 {
576 let 부모순번 = 준비.구조.노드들[순번들[0]].부모순번
577 let 부모 = 준비.구조.노드들[부모순번]
578 let mut 이전행 = 스칼라정수(부모, "startRow")
579 let mut 합 = 인쇄글조각(준비.조각판, "\{")
580 for 멤버 in 순번들 {
581 let 멤버노드 = 준비.구조.노드들[멤버]
582 let 줄수 = 스칼라정수(멤버노드, "startRow") - 이전행
583 if 줄수 > 0 {
584 합 = 인쇄조각이음(
585 준비.조각판,
586 합,
587 인쇄글조각(준비.조각판, 줄접두(줄수, 노드들여쓰기(준비, 멤버)))
588 )
589 }
590 합 = 인쇄조각이음(준비.조각판, 합, 순번인쇄조각(준비, 멤버, 깊이 + 1)?)
591 let 구분자 = if 스칼라논리(준비.구조.노드들[멤버], "spelling.typeMemberComma") { "," } else { ";" }
592 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 구분자))
593 이전행 = 스칼라정수(멤버노드, "endRow")
594 }
595 let 닫기줄수 = 스칼라정수(부모, "endRow") - 이전행
596 let 닫기접두 = if 닫기줄수 > 0 {
597 줄접두(닫기줄수, 노드들여쓰기(준비, 부모순번))
598 } else { "" }
599 return 인쇄조각결과합치기(준비, [
600 Ok(합), 인쇄글조각결과(준비, 닫기접두 + "\}")
601 ])
602 }
603 if 준비.오프셋배치 && !세미콜론 {
604 let 부모순번 = 준비.구조.노드들[순번들[0]].부모순번
605 let 첫줄수 = 리터럴첫줄수(준비, 부모순번, 순번들[0])
606 let mut 몸 = 인쇄글조각(
607 준비.조각판,
608 if 첫줄수 > 0 { 줄접두(첫줄수, 리터럴열(준비, 순번들[0])) } else { " " }
609 )
610 let mut 색인 = 0
611 while 색인 < 순번들.length {
612 if 색인 > 0 {
613 let 접두 = 리터럴사이접두(준비, 순번들[색인 - 1], 순번들[색인])
614 몸 = 인쇄조각이음(준비.조각판, 몸, 인쇄글조각(준비.조각판, "," + 접두))
615 }
616 몸 = 인쇄조각이음(준비.조각판, 몸, 순번인쇄조각(준비, 순번들[색인], 깊이 + 1)?)
617 색인 = 색인 + 1
618 }
619 let 닫기접두 = 리터럴닫기접두(준비, 부모순번, 몸)?
620 let 닫기 = if 닫기접두 != "" { 닫기접두 + "\}" } else { " \}" }
621 return 인쇄조각결과합치기(준비, [
622 인쇄글조각결과(준비, "\{"), Ok(몸), 인쇄글조각결과(준비, 닫기)
623 ])
624 }
625 let mut 합 = 인쇄글조각(준비.조각판, "\{\n"); let mut 색인 = 0
626 while 색인 < 순번들.length {
627 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 들여쓰기(깊이 + 1)))
628 합 = 인쇄조각이음(준비.조각판, 합, 순번인쇄조각(준비, 순번들[색인], 깊이 + 1)?)
629 if 세미콜론 {
630 let 구분자 = if 스칼라논리(
631 준비.구조.노드들[순번들[색인]],
632 "spelling.typeMemberComma"
633 ) { "," } else { ";" }
634 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 구분자))
635 } else if 색인 + 1 < 순번들.length {
636 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, ","))
637 }
638 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "\n"))
639 색인 = 색인 + 1
640 }
641 합 = 인쇄조각이음(
642 준비.조각판,
643 합,
644 인쇄글조각(준비.조각판, 들여쓰기(깊이) + "\}")
645 )
646 Ok(합)
649function 원시노드조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {
650 if 순번 < 0 || 순번 >= 준비.구조.노드들.length { return Err("인쇄 노드 순번이 범위를 벗어났습니다") }
651 let 노드 = 준비.구조.노드들[순번]
652 let 종류 = 노드종류(준비.언어번호, 노드.코드워드)
653 if 종류 == 0 { return Err("인쇄기에 없는 노드 코드입니다: {노드.코드워드}") }
655 if 종류 == 101 { return 자식조각인쇄(준비, 순번, "program", 깊이) }
656 if 종류 == 102 {
657 let 지시들 = 자식순번들(준비, 순번, "directives")
658 let 본문들 = 자식순번들(준비, 순번, "body")
659 if 준비.오프셋배치 {
660 return 인쇄조각결과합치기(준비, [
661 문장목록조각인쇄(준비, 지시들, 0),
662 문장목록조각인쇄(준비, 본문들, 0)
663 ])
664 }
665 return 인쇄조각결과합치기(준비, [
666 문장목록조각인쇄(준비, 지시들, 0),
667 인쇄글조각결과(준비, if 지시들.length > 0 && 본문들.length > 0 { "\n\n" } else { "" }),
668 문장목록조각인쇄(준비, 본문들, 0)
669 ])
670 }
671 if 종류 == 103 {
672 return 인쇄조각결과합치기(준비, [
673 자식조각인쇄(준비, 순번, "value", 깊이),
674 인쇄글조각결과(준비, ";")
675 ])
676 }
677 if 종류 == 104 {
678 if 스칼라있음(노드, "spelling.singleQuote") ||
679 스칼라있음(노드, "spelling.escapeBody") {
680 return 인쇄글결과조각(준비, 철자문자열리터럴(노드))
681 }
682 let 값 = 스칼라문자(노드, "value")
683 let mut 역빗금수 = 0; let mut 큰따옴표 = false; let mut 작은따옴표 = false
684 for 글자 in 값.scalars() {
685 if 글자 == "\\" { 역빗금수 = 역빗금수 + 1 }
686 else {
687 if 역빗금수 % 2 == 0 {
688 if 글자 == "\"" { 큰따옴표 = true }
689 if 글자 == "'" { 작은따옴표 = true }
690 }
691 역빗금수 = 0
692 }
693 }
694 if !큰따옴표 { return 인쇄글조각결과(준비, "\"" + 값 + "\"") }
695 if !작은따옴표 { return 인쇄글조각결과(준비, "'" + 값 + "'") }
696 return Err("지시문 리터럴에 탈출하지 않은 두 따옴표가 함께 있습니다")
697 }
698 if 종류 == 105 {
699 let 식순번 = 자식순번(준비, 순번, "expression")
700 let mut 밑순번 = 식순번
701 if 밑순번 >= 0 &&
702 노드종류(준비.언어번호, 준비.구조.노드들[밑순번].코드워드) == 210 {
703 밑순번 = 자식순번(준비, 밑순번, "callee")
704 }
705 while 밑순번 >= 0 &&
706 노드종류(준비.언어번호, 준비.구조.노드들[밑순번].코드워드) == 208 &&
707 !스칼라논리(준비.구조.노드들[밑순번], "computed") {
708 밑순번 = 자식순번(준비, 밑순번, "object")
709 }
710 // An explicit expression wrapper already supplies the grouping required
711 // by decorator syntax. Babel does not add another synthetic pair around
712 // it, so preserve that same canonical boundary here.
713 let 그대로 = 스칼라정수(준비.구조.노드들[식순번], "spelling.parentheses") > 0 ||
714 (밑순번 >= 0 &&
715 노드종류(준비.언어번호, 준비.구조.노드들[밑순번].코드워드) == 106)
716 return 인쇄조각결과합치기(준비, [
717 인쇄글조각결과(준비, if 그대로 { "@" } else { "@(" }),
718 순번인쇄조각(준비, 식순번, 깊이),
719 인쇄글조각결과(준비, if 그대로 { "" } else { ")" })
720 ])
721 }
722 if 종류 == 106 {
723 let mut 합 = 인쇄글조각(준비.조각판, 식별자이름(준비, 순번)?)
724 if 스칼라논리(노드, "optional") {
725 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "?"))
726 }
727 if 노드.부모순번 >= 0 && 노드.자식필드 == "id" {
728 let 부모 = 준비.구조.노드들[노드.부모순번]
729 if 노드종류(준비.언어번호, 부모.코드워드) == 408 &&
730 스칼라논리(부모, "definite") {
731 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "!"))
732 }
733 }
734 let 형식 = 자식조각인쇄접두(준비, 순번, "typeAnnotation", 깊이, "")?
735 return Ok(인쇄조각이음(준비.조각판, 합, 형식))
736 }
737 if 종류 == 107 {
738 return 인쇄조각결과합치기(준비, [
739 인쇄글조각결과(준비, "#"),
740 자식조각인쇄(준비, 순번, "id", 깊이)
741 ])
742 }
743 if 종류 == 108 { return 인쇄글결과조각(준비, 철자문자열리터럴(노드)) }
744 if 종류 == 109 { return 인쇄글조각결과(준비, 스칼라문자(노드, "value") + "n") }
745 if 종류 == 110 {
746 if 스칼라있음(노드, "spelling.numericLexeme") {
747 return 인쇄글조각결과(준비, 스칼라문자(노드, "spelling.numericLexeme"))
748 }
749 let 값 = 노드스칼라(노드, "value")
750 if 값.태그 == 5 {
751 let 원본 = 값.문자열값
752 if 원본 == "number:-0" { return 인쇄글조각결과(준비, "0") }
753 if 원본 == "number:NaN" { return 인쇄글조각결과(준비, "0 / 0") }
754 if 원본 == "number:Infinity" { return 인쇄글조각결과(준비, "1e999") }
755 if 원본 == "number:-Infinity" { return 인쇄글조각결과(준비, "-1e999") }
756 return 인쇄글조각결과(준비, 글자합치기(원본.scalars(), 7, 원본.scalars().length))
757 }
758 let 숫자 = 스칼라정수(노드, "value")
759 return 인쇄글조각결과(준비, "{숫자}")
760 }
761 if 종류 == 111 { return 인쇄글조각결과(준비, if 스칼라논리(노드, "value") { "true" } else { "false" }) }
762 if 종류 == 112 { return 인쇄글조각결과(준비, "null") }
763 if 종류 == 113 { return 인쇄글조각결과(준비, "this") }
764 if 종류 == 114 { return 인쇄글조각결과(준비, "super") }
765 if 종류 == 115 {
766 return 인쇄글조각결과(
767 준비,
768 "/" + 스칼라문자(노드, "pattern") + "/" + 스칼라문자(노드, "flags")
769 )
770 }
771 if 종류 == 116 { return 인쇄글조각결과(준비, 스칼라문자(노드, "value.raw")) }
772 if 종류 == 117 {
773 let 준문자들 = 자식순번들(준비, 순번, "quasis")
774 let 식들 = 자식순번들(준비, 순번, "expressions")
775 let mut 합 = 인쇄글조각(준비.조각판, "`"); let mut 색인 = 0
776 while 색인 < 준문자들.length {
777 let 준문자인쇄 = if 댓글고정있음(준비) { 댓글노드인쇄조각(준비, 준문자들[색인], 깊이) }
778 else { 노드인쇄조각(준비, 준문자들[색인], 깊이) }
779 합 = 인쇄조각이음(준비.조각판, 합, 준문자인쇄?)
780 if 색인 < 식들.length {
781 let 준문자 = 준비.구조.노드들[준문자들[색인]]
782 let 식노드 = 준비.구조.노드들[식들[색인]]
783 let 식줄수 = 스칼라정수(식노드, "startRow") - 스칼라정수(준문자, "endRow")
784 let 인괄호 = 인괄호필요(준비, 식들[색인])
785 let 식인쇄 = if 댓글고정있음(준비) { 댓글노드인쇄조각(준비, 식들[색인], 깊이) }
786 else { 노드인쇄조각(준비, 식들[색인], 깊이) }
787 합 = 인쇄조각이음(
788 준비.조각판, 합,
789 인쇄글조각(
790 준비.조각판,
791 (if 인괄호 { "$\{(" } else { "$\{" }) +
792 (if 준비.오프셋배치 && 식줄수 > 0 { 줄접두(식줄수, 0) } else { "" })
793 )
794 )
795 합 = 인쇄조각이음(준비.조각판, 합, 식인쇄?)
796 합 = 인쇄조각이음(
797 준비.조각판, 합,
798 인쇄글조각(준비.조각판, if 인괄호 { ")\}" } else { "\}" })
799 )
800 }
801 색인 = 색인 + 1
802 }
803 return Ok(인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "`")))
804 }
805 if 종류 == 118 {
806 let 이름있음 = 자식순번(준비, 순번, "id") >= 0
807 let 몸순번 = 자식순번(준비, 순번, "body")
808 return 인쇄조각결과합치기(준비, [
809 함수머리조각인쇄(준비, 순번, 깊이, 이름있음),
810 인쇄글조각결과(준비, 함수몸접두(준비, 순번, 몸순번)),
811 자식조각인쇄(준비, 순번, "body", 깊이)
812 ])
813 }
814 Err("원시 노드 인쇄 규칙을 찾지 못했습니다: {종류}")
817function 모음노드조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {
818 let 노드 = 준비.구조.노드들[순번]
819 let 종류 = 노드종류(준비.언어번호, 노드.코드워드)
820 if 종류 == 201 || 종류 == 202 {
821 let 무늬 = 종류 == 202
822 if !스칼라있음(노드, "child.elements.length") { return Err("배열 요소 길이가 없습니다") }
823 let 길이 = 스칼라정수(노드, "child.elements.length")
824 if 길이 < 0 { return Err("배열 요소 길이가 음수입니다") }
825 let mut 요소들: Array<int> = []
826 let mut 색인 = 0
827 while 색인 < 길이 { 요소들.push(-1); 색인 = 색인 + 1 }
828 for 자식 in 자식순번들(준비, 순번, "elements") {
829 let 요소 = 준비.구조.노드들[자식]
830 if 요소.자식색인 < 0 || 요소.자식색인 >= 길이 || 요소들[요소.자식색인] >= 0 {
831 return Err("배열 요소 색인이 정규형이 아닙니다")
832 }
833 요소들[요소.자식색인] = 자식
834 }
835 if 준비.오프셋배치 {
836 let mut 첫요소 = -1
837 let mut 마지막요소 = -1
838 for 요소순번 in 요소들 {
839 if 요소순번 >= 0 {
840 if 첫요소 < 0 { 첫요소 = 요소순번 }
841 마지막요소 = 요소순번
842 }
843 }
844 let mut 몸 = 0
845 let mut 이전요소 = -1
846 색인 = 0
847 while 색인 < 요소들.length {
848 if 색인 > 0 { 몸 = 인쇄조각이음(준비.조각판, 몸, 인쇄글조각(준비.조각판, ",")) }
849 if 요소들[색인] >= 0 {
850 let 접두 = if 이전요소 < 0 {
851 let 첫줄수 = 리터럴첫줄수(준비, 순번, 요소들[색인])
852 if 첫줄수 > 0 { 줄접두(첫줄수, 리터럴열(준비, 요소들[색인])) }
853 else if 색인 > 0 { " " } else { "" }
854 } else {
855 리터럴사이접두(준비, 이전요소, 요소들[색인])
856 }
857 몸 = 인쇄조각이음(준비.조각판, 몸, 인쇄글조각(준비.조각판, 접두))
858 let 요소깊이 = if 노드종류(
859 준비.언어번호,
860 준비.구조.노드들[요소들[색인]].코드워드
861 ) == 201 { 깊이 + 1 } else { 깊이 }
862 let 요소결과 = if 무늬 { 순번인쇄조각(준비, 요소들[색인], 깊이) }
863 else { 하위식조각인쇄(준비, 요소들[색인], 요소깊이, 2) }
864 match 요소결과 {
865 case Ok(값) => { 몸 = 인쇄조각이음(준비.조각판, 몸, 값) }
866 case Err(오류) => return Err(오류)
867 }
868 이전요소 = 요소들[색인]
869 }
870 색인 = 색인 + 1
871 }
872 if 요소들.length > 0 && 요소들[요소들.length - 1] < 0 {
873 몸 = 인쇄조각이음(준비.조각판, 몸, 인쇄글조각(준비.조각판, ","))
874 }
875 let mut 합 = 인쇄조각이음(준비.조각판, 인쇄글조각(준비.조각판, "["), 몸)
876 if 마지막요소 >= 0 {
877 let 닫기접두 = 리터럴닫기접두(준비, 순번, 몸)?
878 if 닫기접두 != "" {
879 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 닫기접두))
880 }
881 }
882 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "]"))
883 if 무늬 { 합 = 인쇄조각이음(준비.조각판, 합, 자식조각인쇄접두(준비, 순번, "typeAnnotation", 깊이, "")?) }
884 return Ok(합)
885 }
886 let mut 합 = 인쇄글조각(준비.조각판, "[")
887 색인 = 0
888 while 색인 < 요소들.length {
889 if 색인 > 0 { 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, ",")) }
890 if 요소들[색인] >= 0 {
891 if 색인 > 0 { 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, " ")) }
892 let 요소결과 = if 무늬 { 순번인쇄조각(준비, 요소들[색인], 깊이) }
893 else { 하위식조각인쇄(준비, 요소들[색인], 깊이, 2) }
894 match 요소결과 {
895 case Ok(값) => { 합 = 인쇄조각이음(준비.조각판, 합, 값) }
896 case Err(오류) => return Err(오류)
897 }
898 }
899 색인 = 색인 + 1
900 }
901 if 요소들.length > 0 && 요소들[요소들.length - 1] < 0 {
902 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, ","))
903 }
904 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "]"))
905 if 무늬 {
906 match 자식조각인쇄접두(준비, 순번, "typeAnnotation", 깊이, "") {
907 case Ok(형식) => { 합 = 인쇄조각이음(준비.조각판, 합, 형식) }
908 case Err(오류) => return Err(오류)
909 }
910 }
911 return Ok(합)
912 }
913 if 종류 == 203 { return 중괄호목록조각인쇄(준비, 자식순번들(준비, 순번, "properties"), 깊이, false) }
914 if 종류 == 204 { return 중괄호목록조각인쇄(준비, 자식순번들(준비, 순번, "properties"), 깊이, false) }
915 if 종류 == 205 {
916 let 키순번 = 자식순번(준비, 순번, "key")
917 let 값순번 = 자식순번(준비, 순번, "value")
918 let 계산 = 스칼라논리(노드, "computed")
919 let 키 = match if 계산 && 키순번 >= 0 { 하위식조각인쇄(준비, 키순번, 깊이, 2) }
920 else if 댓글고정있음(준비) { 댓글노드인쇄조각(준비, 키순번, 깊이) }
921 else { 노드인쇄조각(준비, 키순번, 깊이) } {
922 case Ok(조각) => 조각
923 case Err(오류) => return Err(오류)
924 }
925 let 값 = match 하위식조각인쇄(준비, 값순번, 깊이, 2) {
926 case Ok(조각) => 조각
927 case Err(오류) => return Err(오류)
928 }
929 if 스칼라논리(노드, "shorthand") {
930 if 인쇄조각같음(준비.조각판, 키, 값)? { return Ok(키) }
931 if 노드종류(준비.언어번호, 준비.구조.노드들[값순번].코드워드) == 306 {
932 let 왼순번 = 자식순번(준비, 값순번, "left")
933 if 왼순번 >= 0 &&
934 노드종류(준비.언어번호, 준비.구조.노드들[왼순번].코드워드) == 106 &&
935 인쇄조각같음(
936 준비.조각판,
937 키,
938 인쇄글조각(준비.조각판, 식별자이름(준비, 왼순번)?)
939 )? { return Ok(값) }
940 }
941 }
942 let 키글 = if 계산 {
943 인쇄조각결과합치기(준비, [
944 인쇄글조각결과(준비, "[" + 가장자리접두(준비, 키순번, "")),
945 Ok(키), 인쇄글조각결과(준비, "]")
946 ])?
947 } else { 키 }
948 return 인쇄조각결과합치기(준비, [
949 Ok(키글), 인쇄글조각결과(준비, ":" + 가장자리접두(준비, 값순번, " ")), Ok(값)
950 ])
951 }
952 if 종류 == 206 {
953 let 인수순번 = 자식순번(준비, 순번, "argument")
954 return 인쇄조각결과합치기(준비, [
955 인쇄글조각결과(준비, "..." + 가장자리접두(준비, 인수순번, "")),
956 하위식조각인쇄(준비, 인수순번, 깊이, 2)
957 ])
958 }
959 if 종류 == 207 {
960 return 인쇄조각결과합치기(준비, [
961 인쇄글조각결과(준비, "..."),
962 자식조각인쇄(준비, 순번, "argument", 깊이),
963 자식조각인쇄접두(준비, 순번, "typeAnnotation", 깊이, "")
964 ])
965 }
966 if 종류 == 208 || 종류 == 209 {
967 let 선택 = 종류 == 209
968 let 대상순번 = 자식순번(준비, 순번, "object")
969 let 속성순번 = 자식순번(준비, 순번, "property")
970 let 대상종류 = if 대상순번 < 0 { 0 }
971 else { 노드종류(준비.언어번호, 준비.구조.노드들[대상순번].코드워드) }
972 let 대상 = match 연쇄대상조각인쇄(준비, 대상순번, 깊이, 선택) {
973 case Ok(조각) => if 대상종류 == 727 &&
974 스칼라정수(준비.구조.노드들[대상순번], "spelling.parentheses") == 0 {
975 인쇄조각결과합치기(준비, [
976 인쇄글조각결과(준비, "("), Ok(조각), 인쇄글조각결과(준비, ")")
977 ])?
978 } else { 조각 }
979 case Err(오류) => return Err(오류)
980 }
981 if 스칼라논리(노드, "computed") {
982 let 접근접두 = if 대상순번 >= 0 && 속성순번 >= 0 {
983 가장자리접두(준비, 속성순번, "")
984 } else { "" }
985 return 인쇄조각결과합치기(준비, [
986 Ok(대상),
987 인쇄글조각결과(준비, (if 선택 && 스칼라논리(노드, "optional") { "?." } else { "" }) + "["),
988 인쇄글조각결과(준비, 접근접두),
989 자식조각인쇄(준비, 순번, "property", 깊이),
990 인쇄글조각결과(준비, "]")
991 ])
992 }
993 let mut 정수대상 = false
994 if !선택 && 대상순번 >= 0 && 대상종류 == 110 {
995 let 숫자값 = 노드스칼라(준비.구조.노드들[대상순번], "value")
996 정수대상 = 숫자값.태그 == 3
997 if 숫자값.태그 == 5 {
998 let 글자들 = 숫자값.문자열값.scalars()
999 let mut 색인 = 7
1000 정수대상 = 색인 < 글자들.length

SHA256 887fab33ce619d402403f3eb50e666a165a5a42e1ddec997428415f18eef2907