From 4702271102a2d4e21486082c2da0ac4d8101b16c Mon Sep 17 00:00:00 2001 From: Paolo Tranquilli Date: Thu, 3 Nov 2022 13:04:33 +0100 Subject: [PATCH] Swift: add `cfg.swift` to AST tests --- .pre-commit-config.yaml | 2 +- config/identical-files.json | 6 +- .../test/library-tests/ast/PrintAst.expected | 2734 +++++++++++++++++ swift/ql/test/library-tests/ast/cfg.swift | 494 +++ 4 files changed, 3234 insertions(+), 2 deletions(-) create mode 100644 swift/ql/test/library-tests/ast/cfg.swift diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index d51681aa65c..50a6adf80d9 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -31,7 +31,7 @@ repos: - id: sync-files name: Fix files required to be identical - files: \.(qll?|qhelp|swift)$ + files: \.(qll?|qhelp|swift)$|^config/identical-files\.json$ language: system entry: python3 config/sync-files.py --latest pass_filenames: false diff --git a/config/identical-files.json b/config/identical-files.json index 832fac7741c..91056103836 100644 --- a/config/identical-files.json +++ b/config/identical-files.json @@ -600,8 +600,12 @@ "swift/ql/test/extractor-tests/patterns/patterns.swift", "swift/ql/test/library-tests/ast/patterns.swift" ], + "Swift control flow test file": [ + "swift/ql/test/library-tests/controlflow/graph/cfg.swift", + "swift/ql/test/library-tests/ast/cfg.swift" + ], "IncompleteMultiCharacterSanitization JS/Ruby": [ "javascript/ql/lib/semmle/javascript/security/IncompleteMultiCharacterSanitizationQuery.qll", "ruby/ql/lib/codeql/ruby/security/IncompleteMultiCharacterSanitizationQuery.qll" ] -} \ No newline at end of file +} diff --git a/swift/ql/test/library-tests/ast/PrintAst.expected b/swift/ql/test/library-tests/ast/PrintAst.expected index 7d69dd9a47d..aa2c1c15c64 100644 --- a/swift/ql/test/library-tests/ast/PrintAst.expected +++ b/swift/ql/test/library-tests/ast/PrintAst.expected @@ -1,8 +1,2742 @@ #-----| [ModuleDecl] __ObjC +#-----| [ModuleDecl] cfg #-----| [ModuleDecl] declarations #-----| [ModuleDecl] expressions #-----| [ModuleDecl] patterns #-----| [ModuleDecl] statements +cfg.swift: +# 1| [TopLevelCodeDecl] { ... } +# 1| getBody(): [BraceStmt] { ... } +# 1| getElement(0): [PatternBindingDecl] var ... = ... +# 1| getInit(0): [IntegerLiteralExpr] 0 +# 1| getPattern(0): [TypedPattern] ... as ... +# 1| getSubPattern(): [NamedPattern] topLevelDecl +# 1| getTypeRepr(): [TypeRepr] Int +# 1| [ConcreteVarDecl] topLevelDecl +# 1| Type = Int +# 2| [TopLevelCodeDecl] { ... } +# 2| getBody(): [BraceStmt] { ... } +# 2| getElement(0): [IntegerLiteralExpr] 0 +# 3| [TopLevelCodeDecl] { ... } +# 3| getBody(): [BraceStmt] { ... } +# 3| getElement(0): [BinaryExpr] ... .+(_:_:) ... +# 3| getFunction(): [MethodRefExpr] .+(_:_:) +# 3| getBase(): [TypeExpr] Int.Type +# 3| getTypeRepr(): [TypeRepr] Int +# 3| getArgument(0): [Argument] : topLevelDecl +# 3| getExpr(): [DeclRefExpr] topLevelDecl +# 3| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 3| getArgument(1): [Argument] : 1 +# 3| getExpr(): [IntegerLiteralExpr] 1 +# 5| [ConcreteFuncDecl] returnZero() +# 5| InterfaceType = () -> Int +# 5| getBody(): [BraceStmt] { ... } +# 5| getElement(0): [ReturnStmt] return ... +# 5| getResult(): [IntegerLiteralExpr] 0 +# 7| [TopLevelCodeDecl] { ... } +# 7| getBody(): [BraceStmt] { ... } +# 7| getElement(0): [CallExpr] call to returnZero() +# 7| getFunction(): [DeclRefExpr] returnZero() +# 8| [TopLevelCodeDecl] { ... } +# 8| getBody(): [BraceStmt] { ... } +# 8| getElement(0): [CallExpr] call to init(_:) +# 8| getFunction(): [ConstructorRefCallExpr] call to init(_:) +# 8| getFunction(): [DeclRefExpr] init(_:) +# 8| getArgument(0): [Argument] : Double.Type +# 8| getExpr(): [TypeExpr] Double.Type +# 8| getTypeRepr(): [TypeRepr] Double +# 8| getArgument(0): [Argument] : topLevelDecl +# 8| getExpr(): [DeclRefExpr] topLevelDecl +# 8| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 10| [EnumDecl] MyError +# 11| getMember(0): [EnumCaseDecl] case ... +# 11| getMember(1): [EnumElementDecl] error1 +# 11| getMember(2): [EnumElementDecl] error2 +# 12| getMember(3): [EnumCaseDecl] case ... +# 12| getMember(4): [EnumElementDecl] error3 +# 12| getParam(0): [ParamDecl] withParam +# 12| Type = Int +# 15| [ConcreteFuncDecl] isZero(x:) +# 15| InterfaceType = (Int) -> Bool +# 15| getParam(0): [ParamDecl] x +# 15| Type = Int +# 15| getBody(): [BraceStmt] { ... } +# 15| getElement(0): [ReturnStmt] return ... +# 15| getResult(): [BinaryExpr] ... .==(_:_:) ... +# 15| getFunction(): [MethodRefExpr] .==(_:_:) +# 15| getBase(): [TypeExpr] Int.Type +# 15| getTypeRepr(): [TypeRepr] Int +# 15| getArgument(0): [Argument] : x +# 15| getExpr(): [DeclRefExpr] x +# 15| getArgument(1): [Argument] : 0 +# 15| getExpr(): [IntegerLiteralExpr] 0 +# 17| [ConcreteFuncDecl] mightThrow(x:) +# 17| InterfaceType = (Int) throws -> Void +# 17| getParam(0): [ParamDecl] x +# 17| Type = Int +# 17| getBody(): [BraceStmt] { ... } +# 18| getElement(0): [GuardStmt] guard ... else { ... } +# 18| getCondition(): [StmtCondition] StmtCondition +# 18| getElement(0): [ConditionElement] ... .>=(_:_:) ... +# 18| getBoolean(): [BinaryExpr] ... .>=(_:_:) ... +# 18| getFunction(): [MethodRefExpr] .>=(_:_:) +# 18| getBase(): [TypeExpr] Int.Type +# 18| getTypeRepr(): [TypeRepr] Int +# 18| getArgument(0): [Argument] : x +# 18| getExpr(): [DeclRefExpr] x +# 18| getArgument(1): [Argument] : 0 +# 18| getExpr(): [IntegerLiteralExpr] 0 +# 18| getBody(): [BraceStmt] { ... } +# 19| getElement(0): [ThrowStmt] throw ... +# 19| getSubExpr(): [MethodRefExpr] .error1 +# 19| getBase(): [TypeExpr] MyError.Type +# 19| getTypeRepr(): [TypeRepr] MyError +# 19| getSubExpr().getFullyConverted(): [ErasureExpr] (Error) ... +# 21| getElement(1): [GuardStmt] guard ... else { ... } +# 21| getCondition(): [StmtCondition] StmtCondition +# 21| getElement(0): [ConditionElement] ... .<=(_:_:) ... +# 21| getBoolean(): [BinaryExpr] ... .<=(_:_:) ... +# 21| getFunction(): [MethodRefExpr] .<=(_:_:) +# 21| getBase(): [TypeExpr] Int.Type +# 21| getTypeRepr(): [TypeRepr] Int +# 21| getArgument(0): [Argument] : x +# 21| getExpr(): [DeclRefExpr] x +# 21| getArgument(1): [Argument] : 0 +# 21| getExpr(): [IntegerLiteralExpr] 0 +# 21| getBody(): [BraceStmt] { ... } +# 22| getElement(0): [ThrowStmt] throw ... +# 22| getSubExpr(): [CallExpr] call to ... +# 22| getFunction(): [MethodRefExpr] .error3 +# 22| getBase(): [TypeExpr] MyError.Type +# 22| getTypeRepr(): [TypeRepr] MyError +# 22| getArgument(0): [Argument] withParam: ... .+(_:_:) ... +# 22| getExpr(): [BinaryExpr] ... .+(_:_:) ... +# 22| getFunction(): [MethodRefExpr] .+(_:_:) +# 22| getBase(): [TypeExpr] Int.Type +# 22| getTypeRepr(): [TypeRepr] Int +# 22| getArgument(0): [Argument] : x +# 22| getExpr(): [DeclRefExpr] x +# 22| getArgument(1): [Argument] : 1 +# 22| getExpr(): [IntegerLiteralExpr] 1 +# 22| getSubExpr().getFullyConverted(): [ErasureExpr] (Error) ... +# 26| [ConcreteFuncDecl] tryCatch(x:) +# 26| InterfaceType = (Int) -> Int +# 26| getParam(0): [ParamDecl] x +# 26| Type = Int +# 26| getBody(): [BraceStmt] { ... } +# 27| getElement(0): [DoCatchStmt] do { ... } catch { ... } +# 27| getBody(): [BraceStmt] { ... } +# 28| getElement(0): [TryExpr] try ... +# 28| getSubExpr(): [CallExpr] call to mightThrow(x:) +# 28| getFunction(): [DeclRefExpr] mightThrow(x:) +# 28| getArgument(0): [Argument] x: 0 +# 28| getExpr(): [IntegerLiteralExpr] 0 +# 29| getElement(1): [CallExpr] call to print(_:separator:terminator:) +# 29| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 29| getArgument(0): [Argument] : [...] +# 29| getExpr(): [VarargExpansionExpr] [...] +# 29| getSubExpr(): [ArrayExpr] [...] +# 29| getElement(0): [StringLiteralExpr] Did not throw. +# 29| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 29| getArgument(1): [Argument] separator: default separator +# 29| getExpr(): [DefaultArgumentExpr] default separator +# 29| getArgument(2): [Argument] terminator: default terminator +# 29| getExpr(): [DefaultArgumentExpr] default terminator +# 30| getElement(2): [ForceTryExpr] try! ... +# 30| getSubExpr(): [CallExpr] call to mightThrow(x:) +# 30| getFunction(): [DeclRefExpr] mightThrow(x:) +# 30| getArgument(0): [Argument] x: 0 +# 30| getExpr(): [IntegerLiteralExpr] 0 +# 31| getElement(3): [CallExpr] call to print(_:separator:terminator:) +# 31| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 31| getArgument(0): [Argument] : [...] +# 31| getExpr(): [VarargExpansionExpr] [...] +# 31| getSubExpr(): [ArrayExpr] [...] +# 31| getElement(0): [StringLiteralExpr] Still did not throw. +# 31| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 31| getArgument(1): [Argument] separator: default separator +# 31| getExpr(): [DefaultArgumentExpr] default separator +# 31| getArgument(2): [Argument] terminator: default terminator +# 31| getExpr(): [DefaultArgumentExpr] default terminator +# 33| getCatch(0): [CaseStmt] case ... +# 33| getBody(): [BraceStmt] { ... } +# 34| getElement(0): [ReturnStmt] return ... +# 34| getResult(): [IntegerLiteralExpr] 0 +# 33| getLabel(0): [CaseLabelItem] ... is ... +# 33| getPattern(): [IsPattern] ... is ... +# 33| getSubPattern(): [EnumElementPattern] .error1 +# 33| getLabel(1): [CaseLabelItem] ... is ... +# 33| getPattern(): [IsPattern] ... is ... +# 33| getSubPattern(): [EnumElementPattern] .error2 +# 35| getCatch(1): [CaseStmt] case ... +# 35| getBody(): [BraceStmt] { ... } +# 36| getElement(0): [ReturnStmt] return ... +# 36| getResult(): [DeclRefExpr] withParam +# 35| getLabel(0): [CaseLabelItem] ... is ... +# 35| getPattern(): [IsPattern] ... is ... +# 35| getSubPattern(): [EnumElementPattern] .error3(...) +# 35| getSubPattern(): [TuplePattern] (...) +# 35| getElement(0): [BindingPattern] let ... +# 35| getSubPattern(): [NamedPattern] withParam +# 37| getCatch(2): [CaseStmt] case ... +# 37| getBody(): [BraceStmt] { ... } +# 38| getElement(0): [CallExpr] call to print(_:separator:terminator:) +# 38| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 38| getArgument(0): [Argument] : [...] +# 38| getExpr(): [VarargExpansionExpr] [...] +# 38| getSubExpr(): [ArrayExpr] [...] +# 38| getElement(0): [StringLiteralExpr] MyError +# 38| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 38| getArgument(1): [Argument] separator: default separator +# 38| getExpr(): [DefaultArgumentExpr] default separator +# 38| getArgument(2): [Argument] terminator: default terminator +# 38| getExpr(): [DefaultArgumentExpr] default terminator +# 37| getLabel(0): [CaseLabelItem] ... is ... +# 37| getPattern(): [IsPattern] ... is ... +# 37| getCastTypeRepr(): [TypeRepr] MyError +# 39| getCatch(3): [CaseStmt] case ... +# 39| getBody(): [BraceStmt] { ... } +# 40| getElement(0): [CallExpr] call to print(_:separator:terminator:) +# 40| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 40| getArgument(0): [Argument] : [...] +# 40| getExpr(): [VarargExpansionExpr] [...] +# 40| getSubExpr(): [ArrayExpr] [...] +# 40| getElement(0): [InterpolatedStringLiteralExpr] "..." +# 40| getAppendingExpr(): [TapExpr] TapExpr +# 40| getSubExpr(): [OpaqueValueExpr] OpaqueValueExpr +# 40| getBody(): [BraceStmt] { ... } +# 40| getElement(1): [CallExpr] call to appendLiteral(_:) +# 40| getFunction(): [MethodRefExpr] .appendLiteral(_:) +# 40| getBase(): [InOutExpr] &... +# 40| getSubExpr(): [DeclRefExpr] $interpolation +# 40| getArgument(0): [Argument] : Unknown error +# 40| getExpr(): [StringLiteralExpr] Unknown error +# 40| getElement(2): [CallExpr] call to appendInterpolation(_:) +# 40| getFunction(): [MethodRefExpr] .appendInterpolation(_:) +# 40| getBase(): [InOutExpr] &... +# 40| getSubExpr(): [DeclRefExpr] $interpolation +# 40| getArgument(0): [Argument] : error +# 40| getExpr(): [DeclRefExpr] error +# 40| getElement(3): [CallExpr] call to appendLiteral(_:) +# 40| getFunction(): [MethodRefExpr] .appendLiteral(_:) +# 40| getBase(): [InOutExpr] &... +# 40| getSubExpr(): [DeclRefExpr] $interpolation +# 40| getArgument(0): [Argument] : +# 40| getExpr(): [StringLiteralExpr] +# 40| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 40| getArgument(1): [Argument] separator: default separator +# 40| getExpr(): [DefaultArgumentExpr] default separator +# 40| getArgument(2): [Argument] terminator: default terminator +# 40| getExpr(): [DefaultArgumentExpr] default terminator +# 39| getLabel(0): [CaseLabelItem] let ... +# 39| getPattern(): [BindingPattern] let ... +# 39| getSubPattern(): [NamedPattern] error +# 42| getElement(1): [ReturnStmt] return ... +# 42| getResult(): [IntegerLiteralExpr] 0 +# 35| [ConcreteVarDecl] withParam +# 35| Type = Int +# 39| [ConcreteVarDecl] error +# 39| Type = Error +# 45| [ConcreteFuncDecl] createClosure1(s:) +# 45| InterfaceType = (String) -> () -> String +# 45| getParam(0): [ParamDecl] s +# 45| Type = String +# 45| getBody(): [BraceStmt] { ... } +# 46| getElement(0): [ReturnStmt] return ... +# 46| getResult(): [ClosureExpr] { ... } +# 46| getBody(): [BraceStmt] { ... } +# 47| getElement(0): [ReturnStmt] return ... +# 47| getResult(): [BinaryExpr] ... .+(_:_:) ... +# 47| getFunction(): [MethodRefExpr] .+(_:_:) +# 47| getBase(): [TypeExpr] String.Type +# 47| getTypeRepr(): [TypeRepr] String +# 47| getArgument(0): [Argument] : s +# 47| getExpr(): [DeclRefExpr] s +# 47| getArgument(1): [Argument] : +# 47| getExpr(): [StringLiteralExpr] +# 51| [ConcreteFuncDecl] createClosure2(x:) +# 51| InterfaceType = (Int) -> (Int) -> Int +# 51| getParam(0): [ParamDecl] x +# 51| Type = Int +# 51| getBody(): [BraceStmt] { ... } +# 52| getElement(0): [ConcreteFuncDecl] f(y:) +# 52| InterfaceType = (Int) -> Int +# 52| getParam(0): [ParamDecl] y +# 52| Type = Int +# 52| getBody(): [BraceStmt] { ... } +# 53| getElement(0): [ReturnStmt] return ... +# 53| getResult(): [BinaryExpr] ... .+(_:_:) ... +# 53| getFunction(): [MethodRefExpr] .+(_:_:) +# 53| getBase(): [TypeExpr] Int.Type +# 53| getTypeRepr(): [TypeRepr] Int +# 53| getArgument(0): [Argument] : x +# 53| getExpr(): [DeclRefExpr] x +# 53| getArgument(1): [Argument] : y +# 53| getExpr(): [DeclRefExpr] y +# 55| getElement(1): [ReturnStmt] return ... +# 55| getResult(): [DeclRefExpr] f(y:) +# 58| [ConcreteFuncDecl] createClosure3(x:) +# 58| InterfaceType = (Int) -> (Int) -> Int +# 58| getParam(0): [ParamDecl] x +# 58| Type = Int +# 58| getBody(): [BraceStmt] { ... } +# 59| getElement(0): [ReturnStmt] return ... +# 59| getResult(): [ClosureExpr] { ... } +# 60| getParam(0): [ParamDecl] y +# 60| Type = Int +# 59| getBody(): [BraceStmt] { ... } +# 60| getElement(0): [ReturnStmt] return ... +# 60| getResult(): [BinaryExpr] ... .+(_:_:) ... +# 60| getFunction(): [MethodRefExpr] .+(_:_:) +# 60| getBase(): [TypeExpr] Int.Type +# 60| getTypeRepr(): [TypeRepr] Int +# 60| getArgument(0): [Argument] : x +# 60| getExpr(): [DeclRefExpr] x +# 60| getArgument(1): [Argument] : y +# 60| getExpr(): [DeclRefExpr] y +# 64| [ConcreteFuncDecl] callClosures() +# 64| InterfaceType = () -> () +# 64| getBody(): [BraceStmt] { ... } +# 65| getElement(0): [PatternBindingDecl] var ... = ... +# 65| getInit(0): [CallExpr] call to ... +# 65| getFunction(): [CallExpr] call to createClosure1(s:) +# 65| getFunction(): [DeclRefExpr] createClosure1(s:) +# 65| getArgument(0): [Argument] s: +# 65| getExpr(): [StringLiteralExpr] +# 65| getPattern(0): [NamedPattern] x1 +# 65| getElement(1): [ConcreteVarDecl] x1 +# 65| Type = String +# 66| getElement(2): [PatternBindingDecl] var ... = ... +# 66| getInit(0): [CallExpr] call to ... +# 66| getFunction(): [CallExpr] call to createClosure2(x:) +# 66| getFunction(): [DeclRefExpr] createClosure2(x:) +# 66| getArgument(0): [Argument] x: 0 +# 66| getExpr(): [IntegerLiteralExpr] 0 +# 66| getArgument(0): [Argument] : 10 +# 66| getExpr(): [IntegerLiteralExpr] 10 +# 66| getPattern(0): [NamedPattern] x2 +# 66| getElement(3): [ConcreteVarDecl] x2 +# 66| Type = Int +# 67| getElement(4): [PatternBindingDecl] var ... = ... +# 67| getInit(0): [CallExpr] call to ... +# 67| getFunction(): [CallExpr] call to createClosure3(x:) +# 67| getFunction(): [DeclRefExpr] createClosure3(x:) +# 67| getArgument(0): [Argument] x: 0 +# 67| getExpr(): [IntegerLiteralExpr] 0 +# 67| getArgument(0): [Argument] : 10 +# 67| getExpr(): [IntegerLiteralExpr] 10 +# 67| getPattern(0): [NamedPattern] x3 +# 67| getElement(5): [ConcreteVarDecl] x3 +# 67| Type = Int +# 70| [ConcreteFuncDecl] maybeParseInt(s:) +# 70| InterfaceType = (String) -> Int? +# 70| getParam(0): [ParamDecl] s +# 70| Type = String +# 70| getBody(): [BraceStmt] { ... } +# 71| getElement(0): [PatternBindingDecl] var ... = ... +# 71| getInit(0): [CallExpr] call to init(_:) +# 71| getFunction(): [ConstructorRefCallExpr] call to init(_:) +# 71| getFunction(): [DeclRefExpr] init(_:) +# 71| getArgument(0): [Argument] : Int.Type +# 71| getExpr(): [TypeExpr] Int.Type +# 71| getTypeRepr(): [TypeRepr] Int +# 71| getArgument(0): [Argument] : s +# 71| getExpr(): [DeclRefExpr] s +# 71| getPattern(0): [TypedPattern] ... as ... +# 71| getSubPattern(): [NamedPattern] n +# 71| getTypeRepr(): [TypeRepr] Int? +# 71| getElement(1): [ConcreteVarDecl] n +# 71| Type = Int? +# 72| getElement(2): [ReturnStmt] return ... +# 72| getResult(): [DeclRefExpr] n +# 72| getResult().getFullyConverted(): [LoadExpr] (Int?) ... +# 75| [ConcreteFuncDecl] forceAndBackToOptional() +# 75| InterfaceType = () -> Int? +# 75| getBody(): [BraceStmt] { ... } +# 76| getElement(0): [PatternBindingDecl] var ... = ... +# 76| getInit(0): [ForceValueExpr] ...! +# 76| getSubExpr(): [CallExpr] call to maybeParseInt(s:) +# 76| getFunction(): [DeclRefExpr] maybeParseInt(s:) +# 76| getArgument(0): [Argument] s: 42 +# 76| getExpr(): [StringLiteralExpr] 42 +# 76| getPattern(0): [NamedPattern] nBang +# 76| getElement(1): [ConcreteVarDecl] nBang +# 76| Type = Int +# 77| getElement(2): [PatternBindingDecl] var ... = ... +# 77| getInit(0): [CallExpr] call to maybeParseInt(s:) +# 77| getFunction(): [DeclRefExpr] maybeParseInt(s:) +# 77| getArgument(0): [Argument] s: 42 +# 77| getExpr(): [StringLiteralExpr] 42 +# 77| getPattern(0): [NamedPattern] n +# 77| getElement(3): [ConcreteVarDecl] n +# 77| Type = Int? +# 78| getElement(4): [ReturnStmt] return ... +# 78| getResult(): [BinaryExpr] ... .+(_:_:) ... +# 78| getFunction(): [MethodRefExpr] .+(_:_:) +# 78| getBase(): [TypeExpr] Int.Type +# 78| getTypeRepr(): [TypeRepr] Int +# 78| getArgument(0): [Argument] : nBang +# 78| getExpr(): [DeclRefExpr] nBang +# 78| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 78| getArgument(1): [Argument] : ...! +# 78| getExpr(): [ForceValueExpr] ...! +# 78| getSubExpr(): [DeclRefExpr] n +# 78| getSubExpr().getFullyConverted(): [LoadExpr] (Int?) ... +# 78| getResult().getFullyConverted(): [InjectIntoOptionalExpr] (Int?) ... +# 81| [ConcreteFuncDecl] testInOut() +# 81| InterfaceType = () -> Int +# 81| getBody(): [BraceStmt] { ... } +# 82| getElement(0): [PatternBindingDecl] var ... = ... +# 82| getInit(0): [IntegerLiteralExpr] 10 +# 82| getPattern(0): [NamedPattern] temp +# 82| getElement(1): [ConcreteVarDecl] temp +# 82| Type = Int +# 84| getElement(2): [ConcreteFuncDecl] add(a:) +# 84| InterfaceType = (inout Int) -> () +# 84| getParam(0): [ParamDecl] a +# 84| Type = Int +# 84| getBody(): [BraceStmt] { ... } +# 85| getElement(0): [AssignExpr] ... = ... +# 85| getDest(): [DeclRefExpr] a +# 85| getSource(): [BinaryExpr] ... .+(_:_:) ... +# 85| getFunction(): [MethodRefExpr] .+(_:_:) +# 85| getBase(): [TypeExpr] Int.Type +# 85| getTypeRepr(): [TypeRepr] Int +# 85| getArgument(0): [Argument] : a +# 85| getExpr(): [DeclRefExpr] a +# 85| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 85| getArgument(1): [Argument] : 1 +# 85| getExpr(): [IntegerLiteralExpr] 1 +# 88| getElement(3): [ConcreteFuncDecl] addOptional(a:) +# 88| InterfaceType = (inout Int?) -> () +# 88| getParam(0): [ParamDecl] a +# 88| Type = Int? +# 88| getBody(): [BraceStmt] { ... } +# 89| getElement(0): [AssignExpr] ... = ... +# 89| getDest(): [DeclRefExpr] a +# 89| getSource(): [NilLiteralExpr] nil +# 92| getElement(4): [CallExpr] call to add(a:) +# 92| getFunction(): [DeclRefExpr] add(a:) +# 92| getArgument(0): [Argument] a: &... +# 92| getExpr(): [InOutExpr] &... +# 92| getSubExpr(): [DeclRefExpr] temp +# 93| getElement(5): [PatternBindingDecl] var ... = ... +# 93| getInit(0): [IntegerLiteralExpr] 10 +# 93| getInit(0).getFullyConverted(): [InjectIntoOptionalExpr] (Int?) ... +# 93| getPattern(0): [TypedPattern] ... as ... +# 93| getSubPattern(): [NamedPattern] tempOptional +# 93| getTypeRepr(): [TypeRepr] Int? +# 93| getElement(6): [ConcreteVarDecl] tempOptional +# 93| Type = Int? +# 94| getElement(7): [CallExpr] call to addOptional(a:) +# 94| getFunction(): [DeclRefExpr] addOptional(a:) +# 94| getArgument(0): [Argument] a: &... +# 94| getExpr(): [InOutExpr] &... +# 94| getSubExpr(): [DeclRefExpr] tempOptional +# 95| getElement(8): [ReturnStmt] return ... +# 95| getResult(): [BinaryExpr] ... .+(_:_:) ... +# 95| getFunction(): [MethodRefExpr] .+(_:_:) +# 95| getBase(): [TypeExpr] Int.Type +# 95| getTypeRepr(): [TypeRepr] Int +# 95| getArgument(0): [Argument] : temp +# 95| getExpr(): [DeclRefExpr] temp +# 95| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 95| getArgument(1): [Argument] : ...! +# 95| getExpr(): [ForceValueExpr] ...! +# 95| getSubExpr(): [DeclRefExpr] tempOptional +# 95| getSubExpr().getFullyConverted(): [LoadExpr] (Int?) ... +# 98| [ClassDecl] C +# 99| getMember(0): [PatternBindingDecl] var ... = ... +# 99| getPattern(0): [TypedPattern] ... as ... +# 99| getSubPattern(): [NamedPattern] myInt +# 99| getTypeRepr(): [TypeRepr] Int +# 99| getMember(1): [ConcreteVarDecl] myInt +# 99| Type = Int +# 99| getAccessorDecl(0): [AccessorDecl] get +# 99| InterfaceType = (C) -> () -> Int +# 99| getSelfParam(): [ParamDecl] self +# 99| Type = C +# 99| getBody(): [BraceStmt] { ... } +# 100| getMember(2): [ConstructorDecl] init(n:) +# 100| InterfaceType = (C.Type) -> (Int) -> C +# 100| getSelfParam(): [ParamDecl] self +# 100| Type = C +# 100| getParam(0): [ParamDecl] n +# 100| Type = Int +# 100| getBody(): [BraceStmt] { ... } +# 101| getElement(0): [AssignExpr] ... = ... +# 101| getDest(): [MemberRefExpr] .myInt +# 101| getBase(): [DeclRefExpr] self +# 101| getSource(): [DeclRefExpr] n +# 102| getElement(1): [ReturnStmt] return +# 104| getMember(3): [ConcreteFuncDecl] getMyInt() +# 104| InterfaceType = (C) -> () -> Int +# 104| getSelfParam(): [ParamDecl] self +# 104| Type = C +# 104| getBody(): [BraceStmt] { ... } +# 105| getElement(0): [ReturnStmt] return ... +# 105| getResult(): [MemberRefExpr] .myInt +# 105| getBase(): [DeclRefExpr] self +# 98| getMember(4): [DestructorDecl] deinit() +# 98| InterfaceType = (C) -> () -> () +# 98| getSelfParam(): [ParamDecl] self +# 98| Type = C +# 98| getBody(): [BraceStmt] { ... } +# 109| [ConcreteFuncDecl] testMemberRef(param:inoutParam:opt:) +# 109| InterfaceType = (C, inout C, C?) -> () +# 109| getParam(0): [ParamDecl] param +# 109| Type = C +# 109| getParam(1): [ParamDecl] inoutParam +# 109| Type = C +# 109| getParam(2): [ParamDecl] opt +# 109| Type = C? +# 109| getBody(): [BraceStmt] { ... } +# 110| getElement(0): [PatternBindingDecl] var ... = ... +# 110| getInit(0): [CallExpr] call to init(n:) +# 110| getFunction(): [ConstructorRefCallExpr] call to init(n:) +# 110| getFunction(): [DeclRefExpr] init(n:) +# 110| getArgument(0): [Argument] : C.Type +# 110| getExpr(): [TypeExpr] C.Type +# 110| getTypeRepr(): [TypeRepr] C +# 110| getArgument(0): [Argument] n: 42 +# 110| getExpr(): [IntegerLiteralExpr] 42 +# 110| getPattern(0): [NamedPattern] c +# 110| getElement(1): [ConcreteVarDecl] c +# 110| Type = C +# 111| getElement(2): [PatternBindingDecl] var ... = ... +# 111| getInit(0): [MemberRefExpr] .myInt +# 111| getBase(): [DeclRefExpr] c +# 111| getPattern(0): [NamedPattern] n1 +# 111| getElement(3): [ConcreteVarDecl] n1 +# 111| Type = Int +# 112| getElement(4): [PatternBindingDecl] var ... = ... +# 112| getInit(0): [MemberRefExpr] .myInt +# 112| getBase(): [DeclRefExpr] c +# 112| getBase().getFullyConverted(): [DotSelfExpr] .self +# 112| getPattern(0): [NamedPattern] n2 +# 112| getElement(5): [ConcreteVarDecl] n2 +# 112| Type = Int +# 113| getElement(6): [PatternBindingDecl] var ... = ... +# 113| getInit(0): [CallExpr] call to getMyInt() +# 113| getFunction(): [MethodRefExpr] .getMyInt() +# 113| getBase(): [DeclRefExpr] c +# 113| getPattern(0): [NamedPattern] n3 +# 113| getElement(7): [ConcreteVarDecl] n3 +# 113| Type = Int +# 114| getElement(8): [PatternBindingDecl] var ... = ... +# 114| getInit(0): [CallExpr] call to getMyInt() +# 114| getFunction(): [MethodRefExpr] .getMyInt() +# 114| getBase(): [DeclRefExpr] c +# 114| getBase().getFullyConverted(): [DotSelfExpr] .self +# 114| getPattern(0): [NamedPattern] n4 +# 114| getElement(9): [ConcreteVarDecl] n4 +# 114| Type = Int +# 116| getElement(10): [PatternBindingDecl] var ... = ... +# 116| getInit(0): [MemberRefExpr] .myInt +# 116| getBase(): [DeclRefExpr] param +# 116| getPattern(0): [NamedPattern] n5 +# 116| getElement(11): [ConcreteVarDecl] n5 +# 116| Type = Int +# 117| getElement(12): [PatternBindingDecl] var ... = ... +# 117| getInit(0): [MemberRefExpr] .myInt +# 117| getBase(): [DeclRefExpr] param +# 117| getBase().getFullyConverted(): [DotSelfExpr] .self +# 117| getPattern(0): [NamedPattern] n6 +# 117| getElement(13): [ConcreteVarDecl] n6 +# 117| Type = Int +# 118| getElement(14): [PatternBindingDecl] var ... = ... +# 118| getInit(0): [CallExpr] call to getMyInt() +# 118| getFunction(): [MethodRefExpr] .getMyInt() +# 118| getBase(): [DeclRefExpr] param +# 118| getPattern(0): [NamedPattern] n7 +# 118| getElement(15): [ConcreteVarDecl] n7 +# 118| Type = Int +# 119| getElement(16): [PatternBindingDecl] var ... = ... +# 119| getInit(0): [CallExpr] call to getMyInt() +# 119| getFunction(): [MethodRefExpr] .getMyInt() +# 119| getBase(): [DeclRefExpr] param +# 119| getBase().getFullyConverted(): [DotSelfExpr] .self +# 119| getPattern(0): [NamedPattern] n8 +# 119| getElement(17): [ConcreteVarDecl] n8 +# 119| Type = Int +# 121| getElement(18): [PatternBindingDecl] var ... = ... +# 121| getInit(0): [MemberRefExpr] .myInt +# 121| getBase(): [DeclRefExpr] inoutParam +# 121| getBase().getFullyConverted(): [LoadExpr] (C) ... +# 121| getPattern(0): [NamedPattern] n9 +# 121| getElement(19): [ConcreteVarDecl] n9 +# 121| Type = Int +# 122| getElement(20): [PatternBindingDecl] var ... = ... +# 122| getInit(0): [MemberRefExpr] .myInt +# 122| getBase(): [DeclRefExpr] inoutParam +# 122| getBase().getFullyConverted(): [LoadExpr] (C) ... +# 122| getImmediateSubExpr(): [DotSelfExpr] .self +# 122| getPattern(0): [NamedPattern] n10 +# 122| getElement(21): [ConcreteVarDecl] n10 +# 122| Type = Int +# 123| getElement(22): [PatternBindingDecl] var ... = ... +# 123| getInit(0): [CallExpr] call to getMyInt() +# 123| getFunction(): [MethodRefExpr] .getMyInt() +# 123| getBase(): [DeclRefExpr] inoutParam +# 123| getBase().getFullyConverted(): [LoadExpr] (C) ... +# 123| getPattern(0): [NamedPattern] n11 +# 123| getElement(23): [ConcreteVarDecl] n11 +# 123| Type = Int +# 124| getElement(24): [PatternBindingDecl] var ... = ... +# 124| getInit(0): [CallExpr] call to getMyInt() +# 124| getFunction(): [MethodRefExpr] .getMyInt() +# 124| getBase(): [DeclRefExpr] inoutParam +# 124| getBase().getFullyConverted(): [LoadExpr] (C) ... +# 124| getImmediateSubExpr(): [DotSelfExpr] .self +# 124| getPattern(0): [NamedPattern] n12 +# 124| getElement(25): [ConcreteVarDecl] n12 +# 124| Type = Int +# 126| getElement(26): [PatternBindingDecl] var ... = ... +# 126| getInit(0): [MemberRefExpr] .myInt +# 126| getBase(): [ForceValueExpr] ...! +# 126| getSubExpr(): [DeclRefExpr] opt +# 126| getPattern(0): [NamedPattern] n13 +# 126| getElement(27): [ConcreteVarDecl] n13 +# 126| Type = Int +# 127| getElement(28): [PatternBindingDecl] var ... = ... +# 127| getInit(0): [MemberRefExpr] .myInt +# 127| getBase(): [ForceValueExpr] ...! +# 127| getSubExpr(): [DeclRefExpr] opt +# 127| getBase().getFullyConverted(): [DotSelfExpr] .self +# 127| getPattern(0): [NamedPattern] n14 +# 127| getElement(29): [ConcreteVarDecl] n14 +# 127| Type = Int +# 128| getElement(30): [PatternBindingDecl] var ... = ... +# 128| getInit(0): [CallExpr] call to getMyInt() +# 128| getFunction(): [MethodRefExpr] .getMyInt() +# 128| getBase(): [ForceValueExpr] ...! +# 128| getSubExpr(): [DeclRefExpr] opt +# 128| getPattern(0): [NamedPattern] n15 +# 128| getElement(31): [ConcreteVarDecl] n15 +# 128| Type = Int +# 129| getElement(32): [PatternBindingDecl] var ... = ... +# 129| getInit(0): [CallExpr] call to getMyInt() +# 129| getFunction(): [MethodRefExpr] .getMyInt() +# 129| getBase(): [ForceValueExpr] ...! +# 129| getSubExpr(): [DeclRefExpr] opt +# 129| getBase().getFullyConverted(): [DotSelfExpr] .self +# 129| getPattern(0): [NamedPattern] n16 +# 129| getElement(33): [ConcreteVarDecl] n16 +# 129| Type = Int +# 131| getElement(34): [PatternBindingDecl] var ... = ... +# 131| getInit(0): [OptionalEvaluationExpr] OptionalEvaluationExpr +# 131| getSubExpr(): [MemberRefExpr] .myInt +# 131| getBase(): [BindOptionalExpr] ...? +# 131| getSubExpr(): [DeclRefExpr] opt +# 131| getSubExpr().getFullyConverted(): [InjectIntoOptionalExpr] (Int?) ... +# 131| getPattern(0): [NamedPattern] n17 +# 131| getElement(35): [ConcreteVarDecl] n17 +# 131| Type = Int? +# 132| getElement(36): [PatternBindingDecl] var ... = ... +# 132| getInit(0): [OptionalEvaluationExpr] OptionalEvaluationExpr +# 132| getSubExpr(): [MemberRefExpr] .myInt +# 132| getBase(): [BindOptionalExpr] ...? +# 132| getSubExpr(): [DeclRefExpr] opt +# 132| getBase().getFullyConverted(): [DotSelfExpr] .self +# 132| getSubExpr().getFullyConverted(): [InjectIntoOptionalExpr] (Int?) ... +# 132| getPattern(0): [NamedPattern] n18 +# 132| getElement(37): [ConcreteVarDecl] n18 +# 132| Type = Int? +# 133| getElement(38): [PatternBindingDecl] var ... = ... +# 133| getInit(0): [OptionalEvaluationExpr] OptionalEvaluationExpr +# 133| getSubExpr(): [CallExpr] call to getMyInt() +# 133| getFunction(): [MethodRefExpr] .getMyInt() +# 133| getBase(): [BindOptionalExpr] ...? +# 133| getSubExpr(): [DeclRefExpr] opt +# 133| getSubExpr().getFullyConverted(): [InjectIntoOptionalExpr] (Int?) ... +# 133| getPattern(0): [NamedPattern] n19 +# 133| getElement(39): [ConcreteVarDecl] n19 +# 133| Type = Int? +# 134| getElement(40): [PatternBindingDecl] var ... = ... +# 134| getInit(0): [OptionalEvaluationExpr] OptionalEvaluationExpr +# 134| getSubExpr(): [CallExpr] call to getMyInt() +# 134| getFunction(): [MethodRefExpr] .getMyInt() +# 134| getBase(): [BindOptionalExpr] ...? +# 134| getSubExpr(): [DeclRefExpr] opt +# 134| getBase().getFullyConverted(): [DotSelfExpr] .self +# 134| getSubExpr().getFullyConverted(): [InjectIntoOptionalExpr] (Int?) ... +# 134| getPattern(0): [NamedPattern] n20 +# 134| getElement(41): [ConcreteVarDecl] n20 +# 134| Type = Int? +# 137| [ConcreteFuncDecl] patterns(x:) +# 137| InterfaceType = (Int) -> Bool +# 137| getParam(0): [ParamDecl] x +# 137| Type = Int +# 137| getBody(): [BraceStmt] { ... } +# 138| getElement(0): [ForEachStmt] for ... in ... { ... } +# 138| getPattern(): [AnyPattern] _ +# 138| getSequence(): [BinaryExpr] ... ....(_:_:) ... +# 138| getFunction(): [MethodRefExpr] ....(_:_:) +# 138| getBase(): [TypeExpr] Int.Type +# 138| getTypeRepr(): [TypeRepr] Int +# 138| getArgument(0): [Argument] : 0 +# 138| getExpr(): [IntegerLiteralExpr] 0 +# 138| getArgument(1): [Argument] : 10 +# 138| getExpr(): [IntegerLiteralExpr] 10 +# 138| getBody(): [BraceStmt] { ... } +# 140| getElement(1): [SwitchStmt] switch x { ... } +# 140| getExpr(): [DeclRefExpr] x +# 141| getCase(0): [CaseStmt] case ... +# 142| getBody(): [BraceStmt] { ... } +# 142| getElement(0): [ReturnStmt] return ... +# 142| getResult(): [BooleanLiteralExpr] true +# 143| getElement(1): [ReturnStmt] return ... +# 143| getResult(): [BooleanLiteralExpr] true +# 141| getLabel(0): [CaseLabelItem] =~ ... +# 141| getPattern(): [ExprPattern] =~ ... +# 141| getSubExpr(): [IntegerLiteralExpr] 0 +# 141| getLabel(1): [CaseLabelItem] =~ ... +# 141| getPattern(): [ExprPattern] =~ ... +# 141| getSubExpr(): [IntegerLiteralExpr] 1 +# 144| getCase(1): [CaseStmt] case ... +# 145| getBody(): [BraceStmt] { ... } +# 145| getElement(0): [ReturnStmt] return ... +# 145| getResult(): [BooleanLiteralExpr] true +# 144| getLabel(0): [CaseLabelItem] =~ ... +# 144| getPattern(): [ExprPattern] =~ ... +# 144| getSubExpr(): [DeclRefExpr] x +# 146| getCase(2): [CaseStmt] case ... +# 147| getBody(): [BraceStmt] { ... } +# 147| getElement(0): [ReturnStmt] return ... +# 147| getResult(): [BooleanLiteralExpr] false +# 146| getLabel(0): [CaseLabelItem] _ +# 146| getPattern(): [AnyPattern] _ +# 150| getElement(2): [PatternBindingDecl] var ... = ... +# 150| getInit(0): [CallExpr] call to init(n:) +# 150| getFunction(): [ConstructorRefCallExpr] call to init(n:) +# 150| getFunction(): [DeclRefExpr] init(n:) +# 150| getArgument(0): [Argument] : C.Type +# 150| getExpr(): [TypeExpr] C.Type +# 150| getTypeRepr(): [TypeRepr] C +# 150| getArgument(0): [Argument] n: x +# 150| getExpr(): [DeclRefExpr] x +# 150| getInit(0).getFullyConverted(): [ErasureExpr] (AnyObject) ... +# 150| getPattern(0): [TypedPattern] ... as ... +# 150| getSubPattern(): [NamedPattern] obj +# 150| getTypeRepr(): [TypeRepr] AnyObject +# 150| getElement(3): [ConcreteVarDecl] obj +# 150| Type = AnyObject +# 151| getElement(4): [IfStmt] if ... then { ... } +# 151| getCondition(): [StmtCondition] StmtCondition +# 151| getElement(0): [ConditionElement] obj +# 151| getBoolean(): [DeclRefExpr] obj +# 151| getBoolean().getFullyConverted(): [IsExpr] ... is ... +# 151| getImmediateSubExpr(): [LoadExpr] (AnyObject) ... +# 151| getThen(): [BraceStmt] { ... } +# 152| getElement(0): [ReturnStmt] return ... +# 152| getResult(): [BooleanLiteralExpr] true +# 155| getElement(5): [PatternBindingDecl] var ... = ... +# 155| getInit(0): [DeclRefExpr] x +# 155| getInit(0).getFullyConverted(): [InjectIntoOptionalExpr] (Int?) ... +# 155| getPattern(0): [TypedPattern] ... as ... +# 155| getSubPattern(): [NamedPattern] xOptional +# 155| getTypeRepr(): [TypeRepr] Int? +# 155| getElement(6): [ConcreteVarDecl] xOptional +# 155| Type = Int? +# 156| getElement(7): [IfStmt] if ... then { ... } else { ... } +# 156| getCondition(): [StmtCondition] StmtCondition +# 156| getElement(0): [ConditionElement] .some(...) = ... +# 156| getPattern(): [EnumElementPattern] .some(...) +# 156| getSubPattern(): [BindingPattern] let ... +# 156| getSubPattern(): [NamedPattern] x +# 156| getSubPattern().getFullyUnresolved(): [ParenPattern] (...) +# 156| getInitializer(): [DeclRefExpr] xOptional +# 156| getThen(): [BraceStmt] { ... } +# 157| getElement(0): [ReturnStmt] return ... +# 157| getResult(): [BinaryExpr] ... .==(_:_:) ... +# 157| getFunction(): [MethodRefExpr] .==(_:_:) +# 157| getBase(): [TypeExpr] Int.Type +# 157| getTypeRepr(): [TypeRepr] Int +# 157| getArgument(0): [Argument] : x +# 157| getExpr(): [DeclRefExpr] x +# 157| getArgument(1): [Argument] : 0 +# 157| getExpr(): [IntegerLiteralExpr] 0 +# 158| getElse(): [BraceStmt] { ... } +# 159| getElement(0): [ReturnStmt] return ... +# 159| getResult(): [BooleanLiteralExpr] false +# 156| [ConcreteVarDecl] x +# 156| Type = (Int) +# 163| [ConcreteFuncDecl] testDefer(x:) +# 163| InterfaceType = (inout Int) -> () +# 163| getParam(0): [ParamDecl] x +# 163| Type = Int +# 163| getBody(): [BraceStmt] { ... } +# 165| getElement(0): [DeferStmt] defer { ... } +# 165| getBody(): [BraceStmt] { ... } +# 166| getElement(0): [CallExpr] call to print(_:separator:terminator:) +# 166| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 166| getArgument(0): [Argument] : [...] +# 166| getExpr(): [VarargExpansionExpr] [...] +# 166| getSubExpr(): [ArrayExpr] [...] +# 166| getElement(0): [StringLiteralExpr] 4 +# 166| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 166| getArgument(1): [Argument] separator: default separator +# 166| getExpr(): [DefaultArgumentExpr] default separator +# 166| getArgument(2): [Argument] terminator: default terminator +# 166| getExpr(): [DefaultArgumentExpr] default terminator +# 169| getElement(1): [DeferStmt] defer { ... } +# 169| getBody(): [BraceStmt] { ... } +# 170| getElement(0): [CallExpr] call to print(_:separator:terminator:) +# 170| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 170| getArgument(0): [Argument] : [...] +# 170| getExpr(): [VarargExpansionExpr] [...] +# 170| getSubExpr(): [ArrayExpr] [...] +# 170| getElement(0): [StringLiteralExpr] 3 +# 170| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 170| getArgument(1): [Argument] separator: default separator +# 170| getExpr(): [DefaultArgumentExpr] default separator +# 170| getArgument(2): [Argument] terminator: default terminator +# 170| getExpr(): [DefaultArgumentExpr] default terminator +# 173| getElement(2): [DeferStmt] defer { ... } +# 173| getBody(): [BraceStmt] { ... } +# 174| getElement(0): [CallExpr] call to print(_:separator:terminator:) +# 174| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 174| getArgument(0): [Argument] : [...] +# 174| getExpr(): [VarargExpansionExpr] [...] +# 174| getSubExpr(): [ArrayExpr] [...] +# 174| getElement(0): [StringLiteralExpr] 1 +# 174| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 174| getArgument(1): [Argument] separator: default separator +# 174| getExpr(): [DefaultArgumentExpr] default separator +# 174| getArgument(2): [Argument] terminator: default terminator +# 174| getExpr(): [DefaultArgumentExpr] default terminator +# 175| getElement(1): [DeferStmt] defer { ... } +# 175| getBody(): [BraceStmt] { ... } +# 176| getElement(0): [CallExpr] call to print(_:separator:terminator:) +# 176| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 176| getArgument(0): [Argument] : [...] +# 176| getExpr(): [VarargExpansionExpr] [...] +# 176| getSubExpr(): [ArrayExpr] [...] +# 176| getElement(0): [StringLiteralExpr] 2 +# 176| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 176| getArgument(1): [Argument] separator: default separator +# 176| getExpr(): [DefaultArgumentExpr] default separator +# 176| getArgument(2): [Argument] terminator: default terminator +# 176| getExpr(): [DefaultArgumentExpr] default terminator +# 164| [Comment] // Will print 1, 2, 3, 4 +# 164| +# 181| [ConcreteFuncDecl] m1(x:) +# 181| InterfaceType = (Int) -> () +# 181| getParam(0): [ParamDecl] x +# 181| Type = Int +# 181| getBody(): [BraceStmt] { ... } +# 182| getElement(0): [IfStmt] if ... then { ... } else { ... } +# 182| getCondition(): [StmtCondition] StmtCondition +# 182| getElement(0): [ConditionElement] ... .>(_:_:) ... +# 182| getBoolean(): [BinaryExpr] ... .>(_:_:) ... +# 182| getFunction(): [MethodRefExpr] .>(_:_:) +# 182| getBase(): [TypeExpr] Int.Type +# 182| getTypeRepr(): [TypeRepr] Int +# 182| getArgument(0): [Argument] : x +# 182| getExpr(): [DeclRefExpr] x +# 182| getArgument(1): [Argument] : 2 +# 182| getExpr(): [IntegerLiteralExpr] 2 +# 182| getThen(): [BraceStmt] { ... } +# 183| getElement(0): [CallExpr] call to print(_:separator:terminator:) +# 183| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 183| getArgument(0): [Argument] : [...] +# 183| getExpr(): [VarargExpansionExpr] [...] +# 183| getSubExpr(): [ArrayExpr] [...] +# 183| getElement(0): [StringLiteralExpr] x is greater than 2 +# 183| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 183| getArgument(1): [Argument] separator: default separator +# 183| getExpr(): [DefaultArgumentExpr] default separator +# 183| getArgument(2): [Argument] terminator: default terminator +# 183| getExpr(): [DefaultArgumentExpr] default terminator +# 185| getElse(): [IfStmt] if ... then { ... } else { ... } +# 185| getCondition(): [StmtCondition] StmtCondition +# 185| getElement(0): [ConditionElement] ... .&&(_:_:) ... +# 185| getBoolean(): [BinaryExpr] ... .&&(_:_:) ... +# 185| getFunction(): [MethodRefExpr] .&&(_:_:) +# 185| getBase(): [TypeExpr] Bool.Type +# 185| getTypeRepr(): [TypeRepr] Bool +# 185| getArgument(0): [Argument] : ... .&&(_:_:) ... +# 185| getExpr(): [BinaryExpr] ... .&&(_:_:) ... +# 185| getFunction(): [MethodRefExpr] .&&(_:_:) +# 185| getBase(): [TypeExpr] Bool.Type +# 185| getTypeRepr(): [TypeRepr] Bool +# 185| getArgument(0): [Argument] : ... .<=(_:_:) ... +# 185| getExpr(): [BinaryExpr] ... .<=(_:_:) ... +# 185| getFunction(): [MethodRefExpr] .<=(_:_:) +# 185| getBase(): [TypeExpr] Int.Type +# 185| getTypeRepr(): [TypeRepr] Int +# 185| getArgument(0): [Argument] : x +# 185| getExpr(): [DeclRefExpr] x +# 185| getArgument(1): [Argument] : 2 +# 185| getExpr(): [IntegerLiteralExpr] 2 +# 185| getArgument(1): [Argument] : { ... } +# 185| getExpr(): [AutoClosureExpr] { ... } +# 185| getBody(): [BraceStmt] { ... } +# 185| getElement(0): [ReturnStmt] return ... +# 185| getResult(): [BinaryExpr] ... .>(_:_:) ... +# 185| getFunction(): [MethodRefExpr] .>(_:_:) +# 185| getBase(): [TypeExpr] Int.Type +# 185| getTypeRepr(): [TypeRepr] Int +# 185| getArgument(0): [Argument] : x +# 185| getExpr(): [DeclRefExpr] x +# 185| getArgument(1): [Argument] : 0 +# 185| getExpr(): [IntegerLiteralExpr] 0 +# 185| getArgument(1): [Argument] : { ... } +# 185| getExpr(): [AutoClosureExpr] { ... } +# 185| getBody(): [BraceStmt] { ... } +# 185| getElement(0): [ReturnStmt] return ... +# 185| getResult(): [PrefixUnaryExpr] call to !(_:) +# 185| getFunction(): [MethodRefExpr] .!(_:) +# 185| getBase(): [TypeExpr] Bool.Type +# 185| getTypeRepr(): [TypeRepr] Bool +# 185| getArgument(0): [Argument] : ... .==(_:_:) ... +# 185| getExpr(): [BinaryExpr] ... .==(_:_:) ... +# 185| getFunction(): [MethodRefExpr] .==(_:_:) +# 185| getBase(): [TypeExpr] Int.Type +# 185| getTypeRepr(): [TypeRepr] Int +# 185| getArgument(0): [Argument] : x +# 185| getExpr(): [DeclRefExpr] x +# 185| getArgument(1): [Argument] : 5 +# 185| getExpr(): [IntegerLiteralExpr] 5 +# 185| getExpr().getFullyConverted(): [ParenExpr] (...) +# 185| getThen(): [BraceStmt] { ... } +# 186| getElement(0): [CallExpr] call to print(_:separator:terminator:) +# 186| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 186| getArgument(0): [Argument] : [...] +# 186| getExpr(): [VarargExpansionExpr] [...] +# 186| getSubExpr(): [ArrayExpr] [...] +# 186| getElement(0): [StringLiteralExpr] x is 1 +# 186| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 186| getArgument(1): [Argument] separator: default separator +# 186| getExpr(): [DefaultArgumentExpr] default separator +# 186| getArgument(2): [Argument] terminator: default terminator +# 186| getExpr(): [DefaultArgumentExpr] default terminator +# 188| getElse(): [BraceStmt] { ... } +# 189| getElement(0): [CallExpr] call to print(_:separator:terminator:) +# 189| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 189| getArgument(0): [Argument] : [...] +# 189| getExpr(): [VarargExpansionExpr] [...] +# 189| getSubExpr(): [ArrayExpr] [...] +# 189| getElement(0): [StringLiteralExpr] I can't guess the number +# 189| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 189| getArgument(1): [Argument] separator: default separator +# 189| getExpr(): [DefaultArgumentExpr] default separator +# 189| getArgument(2): [Argument] terminator: default terminator +# 189| getExpr(): [DefaultArgumentExpr] default terminator +# 193| [ConcreteFuncDecl] m2(b:) +# 193| InterfaceType = (Bool) -> Int +# 193| getParam(0): [ParamDecl] b +# 193| Type = Bool +# 193| getBody(): [BraceStmt] { ... } +# 194| getElement(0): [IfStmt] if ... then { ... } +# 194| getCondition(): [StmtCondition] StmtCondition +# 194| getElement(0): [ConditionElement] b +# 194| getBoolean(): [DeclRefExpr] b +# 194| getThen(): [BraceStmt] { ... } +# 195| getElement(0): [ReturnStmt] return ... +# 195| getResult(): [IntegerLiteralExpr] 0 +# 197| getElement(1): [ReturnStmt] return ... +# 197| getResult(): [IntegerLiteralExpr] 1 +# 200| [ConcreteFuncDecl] m3(x:) +# 200| InterfaceType = (inout Int) -> Int +# 200| getParam(0): [ParamDecl] x +# 200| Type = Int +# 200| getBody(): [BraceStmt] { ... } +# 201| getElement(0): [IfStmt] if ... then { ... } +# 201| getCondition(): [StmtCondition] StmtCondition +# 201| getElement(0): [ConditionElement] ... .<(_:_:) ... +# 201| getBoolean(): [BinaryExpr] ... .<(_:_:) ... +# 201| getFunction(): [MethodRefExpr] .<(_:_:) +# 201| getBase(): [TypeExpr] Int.Type +# 201| getTypeRepr(): [TypeRepr] Int +# 201| getArgument(0): [Argument] : x +# 201| getExpr(): [DeclRefExpr] x +# 201| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 201| getArgument(1): [Argument] : 0 +# 201| getExpr(): [IntegerLiteralExpr] 0 +# 201| getThen(): [BraceStmt] { ... } +# 202| getElement(0): [AssignExpr] ... = ... +# 202| getDest(): [DeclRefExpr] x +# 202| getSource(): [PrefixUnaryExpr] call to -(_:) +# 202| getFunction(): [MethodRefExpr] .-(_:) +# 202| getBase(): [TypeExpr] Int.Type +# 202| getTypeRepr(): [TypeRepr] Int +# 202| getArgument(0): [Argument] : x +# 202| getExpr(): [DeclRefExpr] x +# 202| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 203| getElement(1): [IfStmt] if ... then { ... } +# 203| getCondition(): [StmtCondition] StmtCondition +# 203| getElement(0): [ConditionElement] ... .>(_:_:) ... +# 203| getBoolean(): [BinaryExpr] ... .>(_:_:) ... +# 203| getFunction(): [MethodRefExpr] .>(_:_:) +# 203| getBase(): [TypeExpr] Int.Type +# 203| getTypeRepr(): [TypeRepr] Int +# 203| getArgument(0): [Argument] : x +# 203| getExpr(): [DeclRefExpr] x +# 203| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 203| getArgument(1): [Argument] : 10 +# 203| getExpr(): [IntegerLiteralExpr] 10 +# 203| getThen(): [BraceStmt] { ... } +# 204| getElement(0): [AssignExpr] ... = ... +# 204| getDest(): [DeclRefExpr] x +# 204| getSource(): [BinaryExpr] ... .-(_:_:) ... +# 204| getFunction(): [MethodRefExpr] .-(_:_:) +# 204| getBase(): [TypeExpr] Int.Type +# 204| getTypeRepr(): [TypeRepr] Int +# 204| getArgument(0): [Argument] : x +# 204| getExpr(): [DeclRefExpr] x +# 204| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 204| getArgument(1): [Argument] : 1 +# 204| getExpr(): [IntegerLiteralExpr] 1 +# 207| getElement(1): [ReturnStmt] return ... +# 207| getResult(): [DeclRefExpr] x +# 207| getResult().getFullyConverted(): [LoadExpr] (Int) ... +# 210| [ConcreteFuncDecl] m4(b1:b2:b3:) +# 210| InterfaceType = (Bool, Bool, Bool) -> String +# 210| getParam(0): [ParamDecl] b1 +# 210| Type = Bool +# 210| getParam(1): [ParamDecl] b2 +# 210| Type = Bool +# 210| getParam(2): [ParamDecl] b3 +# 210| Type = Bool +# 210| getBody(): [BraceStmt] { ... } +# 211| getElement(0): [ReturnStmt] return ... +# 211| getResult(): [IfExpr] ... ? ... : ... +# 211| getCondition(): [IfExpr] ... ? ... : ... +# 211| getCondition(): [DeclRefExpr] b1 +# 211| getThenExpr(): [DeclRefExpr] b2 +# 211| getElseExpr(): [DeclRefExpr] b3 +# 211| getCondition().getFullyConverted(): [ParenExpr] (...) +# 211| getThenExpr(): [StringLiteralExpr] b2 || b3 +# 211| getElseExpr(): [StringLiteralExpr] !b2 || !b3 +# 214| [ConcreteFuncDecl] conversionsInSplitEntry(b:) +# 214| InterfaceType = (Bool) -> String +# 214| getParam(0): [ParamDecl] b +# 214| Type = Bool +# 214| getBody(): [BraceStmt] { ... } +# 215| getElement(0): [IfStmt] if ... then { ... } else { ... } +# 215| getCondition(): [StmtCondition] StmtCondition +# 215| getElement(0): [ConditionElement] ... ? ... : ... +# 215| getBoolean(): [IfExpr] ... ? ... : ... +# 215| getCondition(): [DeclRefExpr] b +# 215| getThenExpr(): [BooleanLiteralExpr] true +# 215| getThenExpr().getFullyConverted(): [ParenExpr] (...) +# 215| getElseExpr(): [BooleanLiteralExpr] false +# 215| getElseExpr().getFullyConverted(): [CoerceExpr] (Bool) ... +# 215| getThen(): [BraceStmt] { ... } +# 216| getElement(0): [ReturnStmt] return ... +# 216| getResult(): [StringLiteralExpr] b +# 218| getElse(): [BraceStmt] { ... } +# 219| getElement(0): [ReturnStmt] return ... +# 219| getResult(): [StringLiteralExpr] !b +# 223| [ConcreteFuncDecl] constant_condition() +# 223| InterfaceType = () -> () +# 223| getBody(): [BraceStmt] { ... } +# 224| getElement(0): [IfStmt] if ... then { ... } +# 224| getCondition(): [StmtCondition] StmtCondition +# 224| getElement(0): [ConditionElement] call to !(_:) +# 224| getBoolean(): [PrefixUnaryExpr] call to !(_:) +# 224| getFunction(): [MethodRefExpr] .!(_:) +# 224| getBase(): [TypeExpr] Bool.Type +# 224| getTypeRepr(): [TypeRepr] Bool +# 224| getArgument(0): [Argument] : true +# 224| getExpr(): [BooleanLiteralExpr] true +# 224| getThen(): [BraceStmt] { ... } +# 225| getElement(0): [CallExpr] call to print(_:separator:terminator:) +# 225| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 225| getArgument(0): [Argument] : [...] +# 225| getExpr(): [VarargExpansionExpr] [...] +# 225| getSubExpr(): [ArrayExpr] [...] +# 225| getElement(0): [StringLiteralExpr] Impossible +# 225| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 225| getArgument(1): [Argument] separator: default separator +# 225| getExpr(): [DefaultArgumentExpr] default separator +# 225| getArgument(2): [Argument] terminator: default terminator +# 225| getExpr(): [DefaultArgumentExpr] default terminator +# 229| [ConcreteFuncDecl] empty_else(b:) +# 229| InterfaceType = (Bool) -> () +# 229| getParam(0): [ParamDecl] b +# 229| Type = Bool +# 229| getBody(): [BraceStmt] { ... } +# 230| getElement(0): [IfStmt] if ... then { ... } else { ... } +# 230| getCondition(): [StmtCondition] StmtCondition +# 230| getElement(0): [ConditionElement] b +# 230| getBoolean(): [DeclRefExpr] b +# 230| getThen(): [BraceStmt] { ... } +# 231| getElement(0): [CallExpr] call to print(_:separator:terminator:) +# 231| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 231| getArgument(0): [Argument] : [...] +# 231| getExpr(): [VarargExpansionExpr] [...] +# 231| getSubExpr(): [ArrayExpr] [...] +# 231| getElement(0): [StringLiteralExpr] true +# 231| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 231| getArgument(1): [Argument] separator: default separator +# 231| getExpr(): [DefaultArgumentExpr] default separator +# 231| getArgument(2): [Argument] terminator: default terminator +# 231| getExpr(): [DefaultArgumentExpr] default terminator +# 233| getElse(): [BraceStmt] { ... } +# 234| getElement(1): [CallExpr] call to print(_:separator:terminator:) +# 234| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 234| getArgument(0): [Argument] : [...] +# 234| getExpr(): [VarargExpansionExpr] [...] +# 234| getSubExpr(): [ArrayExpr] [...] +# 234| getElement(0): [StringLiteralExpr] done +# 234| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 234| getArgument(1): [Argument] separator: default separator +# 234| getExpr(): [DefaultArgumentExpr] default separator +# 234| getArgument(2): [Argument] terminator: default terminator +# 234| getExpr(): [DefaultArgumentExpr] default terminator +# 237| [ConcreteFuncDecl] disjunct(b1:b2:) +# 237| InterfaceType = (Bool, Bool) -> () +# 237| getParam(0): [ParamDecl] b1 +# 237| Type = Bool +# 237| getParam(1): [ParamDecl] b2 +# 237| Type = Bool +# 237| getBody(): [BraceStmt] { ... } +# 238| getElement(0): [IfStmt] if ... then { ... } +# 238| getCondition(): [StmtCondition] StmtCondition +# 238| getElement(0): [ConditionElement] ... .||(_:_:) ... +# 238| getBoolean(): [BinaryExpr] ... .||(_:_:) ... +# 238| getFunction(): [MethodRefExpr] .||(_:_:) +# 238| getBase(): [TypeExpr] Bool.Type +# 238| getTypeRepr(): [TypeRepr] Bool +# 238| getArgument(0): [Argument] : b1 +# 238| getExpr(): [DeclRefExpr] b1 +# 238| getArgument(1): [Argument] : { ... } +# 238| getExpr(): [AutoClosureExpr] { ... } +# 238| getBody(): [BraceStmt] { ... } +# 238| getElement(0): [ReturnStmt] return ... +# 238| getResult(): [DeclRefExpr] b2 +# 238| getBoolean().getFullyConverted(): [ParenExpr] (...) +# 238| getThen(): [BraceStmt] { ... } +# 239| getElement(0): [CallExpr] call to print(_:separator:terminator:) +# 239| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 239| getArgument(0): [Argument] : [...] +# 239| getExpr(): [VarargExpansionExpr] [...] +# 239| getSubExpr(): [ArrayExpr] [...] +# 239| getElement(0): [StringLiteralExpr] b1 or b2 +# 239| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 239| getArgument(1): [Argument] separator: default separator +# 239| getExpr(): [DefaultArgumentExpr] default separator +# 239| getArgument(2): [Argument] terminator: default terminator +# 239| getExpr(): [DefaultArgumentExpr] default terminator +# 243| [ConcreteFuncDecl] binaryExprs(a:b:) +# 243| InterfaceType = (Int, Int) -> () +# 243| getParam(0): [ParamDecl] a +# 243| Type = Int +# 243| getParam(1): [ParamDecl] b +# 243| Type = Int +# 243| getBody(): [BraceStmt] { ... } +# 244| getElement(0): [PatternBindingDecl] var ... = ... +# 244| getInit(0): [BinaryExpr] ... .+(_:_:) ... +# 244| getFunction(): [MethodRefExpr] .+(_:_:) +# 244| getBase(): [TypeExpr] Int.Type +# 244| getTypeRepr(): [TypeRepr] Int +# 244| getArgument(0): [Argument] : a +# 244| getExpr(): [DeclRefExpr] a +# 244| getArgument(1): [Argument] : b +# 244| getExpr(): [DeclRefExpr] b +# 244| getPattern(0): [NamedPattern] c +# 244| getElement(1): [ConcreteVarDecl] c +# 244| Type = Int +# 245| getElement(2): [PatternBindingDecl] var ... = ... +# 245| getInit(0): [BinaryExpr] ... .-(_:_:) ... +# 245| getFunction(): [MethodRefExpr] .-(_:_:) +# 245| getBase(): [TypeExpr] Int.Type +# 245| getTypeRepr(): [TypeRepr] Int +# 245| getArgument(0): [Argument] : a +# 245| getExpr(): [DeclRefExpr] a +# 245| getArgument(1): [Argument] : b +# 245| getExpr(): [DeclRefExpr] b +# 245| getPattern(0): [NamedPattern] d +# 245| getElement(3): [ConcreteVarDecl] d +# 245| Type = Int +# 246| getElement(4): [PatternBindingDecl] var ... = ... +# 246| getInit(0): [BinaryExpr] ... .*(_:_:) ... +# 246| getFunction(): [MethodRefExpr] .*(_:_:) +# 246| getBase(): [TypeExpr] Int.Type +# 246| getTypeRepr(): [TypeRepr] Int +# 246| getArgument(0): [Argument] : a +# 246| getExpr(): [DeclRefExpr] a +# 246| getArgument(1): [Argument] : b +# 246| getExpr(): [DeclRefExpr] b +# 246| getPattern(0): [NamedPattern] e +# 246| getElement(5): [ConcreteVarDecl] e +# 246| Type = Int +# 247| getElement(6): [PatternBindingDecl] var ... = ... +# 247| getInit(0): [BinaryExpr] ... ./(_:_:) ... +# 247| getFunction(): [MethodRefExpr] ./(_:_:) +# 247| getBase(): [TypeExpr] Int.Type +# 247| getTypeRepr(): [TypeRepr] Int +# 247| getArgument(0): [Argument] : a +# 247| getExpr(): [DeclRefExpr] a +# 247| getArgument(1): [Argument] : b +# 247| getExpr(): [DeclRefExpr] b +# 247| getPattern(0): [NamedPattern] f +# 247| getElement(7): [ConcreteVarDecl] f +# 247| Type = Int +# 248| getElement(8): [PatternBindingDecl] var ... = ... +# 248| getInit(0): [BinaryExpr] ... .%(_:_:) ... +# 248| getFunction(): [MethodRefExpr] .%(_:_:) +# 248| getBase(): [TypeExpr] Int.Type +# 248| getTypeRepr(): [TypeRepr] Int +# 248| getArgument(0): [Argument] : a +# 248| getExpr(): [DeclRefExpr] a +# 248| getArgument(1): [Argument] : b +# 248| getExpr(): [DeclRefExpr] b +# 248| getPattern(0): [NamedPattern] g +# 248| getElement(9): [ConcreteVarDecl] g +# 248| Type = Int +# 249| getElement(10): [PatternBindingDecl] var ... = ... +# 249| getInit(0): [BinaryExpr] ... .&(_:_:) ... +# 249| getFunction(): [MethodRefExpr] .&(_:_:) +# 249| getBase(): [TypeExpr] Int.Type +# 249| getTypeRepr(): [TypeRepr] Int +# 249| getArgument(0): [Argument] : a +# 249| getExpr(): [DeclRefExpr] a +# 249| getArgument(1): [Argument] : b +# 249| getExpr(): [DeclRefExpr] b +# 249| getPattern(0): [NamedPattern] h +# 249| getElement(11): [ConcreteVarDecl] h +# 249| Type = Int +# 250| getElement(12): [PatternBindingDecl] var ... = ... +# 250| getInit(0): [BinaryExpr] ... .|(_:_:) ... +# 250| getFunction(): [MethodRefExpr] .|(_:_:) +# 250| getBase(): [TypeExpr] Int.Type +# 250| getTypeRepr(): [TypeRepr] Int +# 250| getArgument(0): [Argument] : a +# 250| getExpr(): [DeclRefExpr] a +# 250| getArgument(1): [Argument] : b +# 250| getExpr(): [DeclRefExpr] b +# 250| getPattern(0): [NamedPattern] i +# 250| getElement(13): [ConcreteVarDecl] i +# 250| Type = Int +# 251| getElement(14): [PatternBindingDecl] var ... = ... +# 251| getInit(0): [BinaryExpr] ... .^(_:_:) ... +# 251| getFunction(): [MethodRefExpr] .^(_:_:) +# 251| getBase(): [TypeExpr] Int.Type +# 251| getTypeRepr(): [TypeRepr] Int +# 251| getArgument(0): [Argument] : a +# 251| getExpr(): [DeclRefExpr] a +# 251| getArgument(1): [Argument] : b +# 251| getExpr(): [DeclRefExpr] b +# 251| getPattern(0): [NamedPattern] j +# 251| getElement(15): [ConcreteVarDecl] j +# 251| Type = Int +# 252| getElement(16): [PatternBindingDecl] var ... = ... +# 252| getInit(0): [BinaryExpr] ... .<<(_:_:) ... +# 252| getFunction(): [MethodRefExpr] .<<(_:_:) +# 252| getBase(): [TypeExpr] Int.Type +# 252| getTypeRepr(): [TypeRepr] Int +# 252| getArgument(0): [Argument] : a +# 252| getExpr(): [DeclRefExpr] a +# 252| getArgument(1): [Argument] : b +# 252| getExpr(): [DeclRefExpr] b +# 252| getPattern(0): [NamedPattern] k +# 252| getElement(17): [ConcreteVarDecl] k +# 252| Type = Int +# 253| getElement(18): [PatternBindingDecl] var ... = ... +# 253| getInit(0): [BinaryExpr] ... .>>(_:_:) ... +# 253| getFunction(): [MethodRefExpr] .>>(_:_:) +# 253| getBase(): [TypeExpr] Int.Type +# 253| getTypeRepr(): [TypeRepr] Int +# 253| getArgument(0): [Argument] : a +# 253| getExpr(): [DeclRefExpr] a +# 253| getArgument(1): [Argument] : b +# 253| getExpr(): [DeclRefExpr] b +# 253| getPattern(0): [NamedPattern] l +# 253| getElement(19): [ConcreteVarDecl] l +# 253| Type = Int +# 254| getElement(20): [PatternBindingDecl] var ... = ... +# 254| getInit(0): [BinaryExpr] ... .==(_:_:) ... +# 254| getFunction(): [MethodRefExpr] .==(_:_:) +# 254| getBase(): [TypeExpr] Int.Type +# 254| getTypeRepr(): [TypeRepr] Int +# 254| getArgument(0): [Argument] : a +# 254| getExpr(): [DeclRefExpr] a +# 254| getArgument(1): [Argument] : b +# 254| getExpr(): [DeclRefExpr] b +# 254| getPattern(0): [NamedPattern] o +# 254| getElement(21): [ConcreteVarDecl] o +# 254| Type = Bool +# 255| getElement(22): [PatternBindingDecl] var ... = ... +# 255| getInit(0): [BinaryExpr] ... .!=(_:_:) ... +# 255| getFunction(): [MethodRefExpr] .!=(_:_:) +# 255| getBase(): [TypeExpr] Int.Type +# 255| getTypeRepr(): [TypeRepr] Int +# 255| getArgument(0): [Argument] : a +# 255| getExpr(): [DeclRefExpr] a +# 255| getArgument(1): [Argument] : b +# 255| getExpr(): [DeclRefExpr] b +# 255| getPattern(0): [NamedPattern] p +# 255| getElement(23): [ConcreteVarDecl] p +# 255| Type = Bool +# 256| getElement(24): [PatternBindingDecl] var ... = ... +# 256| getInit(0): [BinaryExpr] ... .<(_:_:) ... +# 256| getFunction(): [MethodRefExpr] .<(_:_:) +# 256| getBase(): [TypeExpr] Int.Type +# 256| getTypeRepr(): [TypeRepr] Int +# 256| getArgument(0): [Argument] : a +# 256| getExpr(): [DeclRefExpr] a +# 256| getArgument(1): [Argument] : b +# 256| getExpr(): [DeclRefExpr] b +# 256| getPattern(0): [NamedPattern] q +# 256| getElement(25): [ConcreteVarDecl] q +# 256| Type = Bool +# 257| getElement(26): [PatternBindingDecl] var ... = ... +# 257| getInit(0): [BinaryExpr] ... .<=(_:_:) ... +# 257| getFunction(): [MethodRefExpr] .<=(_:_:) +# 257| getBase(): [TypeExpr] Int.Type +# 257| getTypeRepr(): [TypeRepr] Int +# 257| getArgument(0): [Argument] : a +# 257| getExpr(): [DeclRefExpr] a +# 257| getArgument(1): [Argument] : b +# 257| getExpr(): [DeclRefExpr] b +# 257| getPattern(0): [NamedPattern] r +# 257| getElement(27): [ConcreteVarDecl] r +# 257| Type = Bool +# 258| getElement(28): [PatternBindingDecl] var ... = ... +# 258| getInit(0): [BinaryExpr] ... .>(_:_:) ... +# 258| getFunction(): [MethodRefExpr] .>(_:_:) +# 258| getBase(): [TypeExpr] Int.Type +# 258| getTypeRepr(): [TypeRepr] Int +# 258| getArgument(0): [Argument] : a +# 258| getExpr(): [DeclRefExpr] a +# 258| getArgument(1): [Argument] : b +# 258| getExpr(): [DeclRefExpr] b +# 258| getPattern(0): [NamedPattern] s +# 258| getElement(29): [ConcreteVarDecl] s +# 258| Type = Bool +# 259| getElement(30): [PatternBindingDecl] var ... = ... +# 259| getInit(0): [BinaryExpr] ... .>=(_:_:) ... +# 259| getFunction(): [MethodRefExpr] .>=(_:_:) +# 259| getBase(): [TypeExpr] Int.Type +# 259| getTypeRepr(): [TypeRepr] Int +# 259| getArgument(0): [Argument] : a +# 259| getExpr(): [DeclRefExpr] a +# 259| getArgument(1): [Argument] : b +# 259| getExpr(): [DeclRefExpr] b +# 259| getPattern(0): [NamedPattern] t +# 259| getElement(31): [ConcreteVarDecl] t +# 259| Type = Bool +# 262| [ConcreteFuncDecl] interpolatedString(x:y:) +# 262| InterfaceType = (Int, Int) -> String +# 262| getParam(0): [ParamDecl] x +# 262| Type = Int +# 262| getParam(1): [ParamDecl] y +# 262| Type = Int +# 262| getBody(): [BraceStmt] { ... } +# 263| getElement(0): [ReturnStmt] return ... +# 263| getResult(): [InterpolatedStringLiteralExpr] "..." +# 263| getAppendingExpr(): [TapExpr] TapExpr +# 263| getSubExpr(): [OpaqueValueExpr] OpaqueValueExpr +# 263| getBody(): [BraceStmt] { ... } +# 263| getElement(1): [CallExpr] call to appendLiteral(_:) +# 263| getFunction(): [MethodRefExpr] .appendLiteral(_:) +# 263| getBase(): [InOutExpr] &... +# 263| getSubExpr(): [DeclRefExpr] $interpolation +# 263| getArgument(0): [Argument] : +# 263| getExpr(): [StringLiteralExpr] +# 263| getElement(2): [CallExpr] call to appendInterpolation(_:) +# 263| getFunction(): [MethodRefExpr] .appendInterpolation(_:) +# 263| getBase(): [InOutExpr] &... +# 263| getSubExpr(): [DeclRefExpr] $interpolation +# 263| getArgument(0): [Argument] : x +# 263| getExpr(): [DeclRefExpr] x +# 263| getElement(3): [CallExpr] call to appendLiteral(_:) +# 263| getFunction(): [MethodRefExpr] .appendLiteral(_:) +# 263| getBase(): [InOutExpr] &... +# 263| getSubExpr(): [DeclRefExpr] $interpolation +# 263| getArgument(0): [Argument] : + +# 263| getExpr(): [StringLiteralExpr] + +# 263| getElement(4): [CallExpr] call to appendInterpolation(_:) +# 263| getFunction(): [MethodRefExpr] .appendInterpolation(_:) +# 263| getBase(): [InOutExpr] &... +# 263| getSubExpr(): [DeclRefExpr] $interpolation +# 263| getArgument(0): [Argument] : y +# 263| getExpr(): [DeclRefExpr] y +# 263| getElement(5): [CallExpr] call to appendLiteral(_:) +# 263| getFunction(): [MethodRefExpr] .appendLiteral(_:) +# 263| getBase(): [InOutExpr] &... +# 263| getSubExpr(): [DeclRefExpr] $interpolation +# 263| getArgument(0): [Argument] : is equal to +# 263| getExpr(): [StringLiteralExpr] is equal to +# 263| getElement(6): [CallExpr] call to appendInterpolation(_:) +# 263| getFunction(): [MethodRefExpr] .appendInterpolation(_:) +# 263| getBase(): [InOutExpr] &... +# 263| getSubExpr(): [DeclRefExpr] $interpolation +# 263| getArgument(0): [Argument] : ... .+(_:_:) ... +# 263| getExpr(): [BinaryExpr] ... .+(_:_:) ... +# 263| getFunction(): [MethodRefExpr] .+(_:_:) +# 263| getBase(): [TypeExpr] Int.Type +# 263| getTypeRepr(): [TypeRepr] Int +# 263| getArgument(0): [Argument] : x +# 263| getExpr(): [DeclRefExpr] x +# 263| getArgument(1): [Argument] : y +# 263| getExpr(): [DeclRefExpr] y +# 263| getElement(7): [CallExpr] call to appendLiteral(_:) +# 263| getFunction(): [MethodRefExpr] .appendLiteral(_:) +# 263| getBase(): [InOutExpr] &... +# 263| getSubExpr(): [DeclRefExpr] $interpolation +# 263| getArgument(0): [Argument] : and here is a zero: +# 263| getExpr(): [StringLiteralExpr] and here is a zero: +# 263| getElement(8): [CallExpr] call to appendInterpolation(_:) +# 263| getFunction(): [MethodRefExpr] .appendInterpolation(_:) +# 263| getBase(): [InOutExpr] &... +# 263| getSubExpr(): [DeclRefExpr] $interpolation +# 263| getArgument(0): [Argument] : call to returnZero() +# 263| getExpr(): [CallExpr] call to returnZero() +# 263| getFunction(): [DeclRefExpr] returnZero() +# 263| getElement(9): [CallExpr] call to appendLiteral(_:) +# 263| getFunction(): [MethodRefExpr] .appendLiteral(_:) +# 263| getBase(): [InOutExpr] &... +# 263| getSubExpr(): [DeclRefExpr] $interpolation +# 263| getArgument(0): [Argument] : +# 263| getExpr(): [StringLiteralExpr] +# 266| [ConcreteFuncDecl] testSubscriptExpr() +# 266| InterfaceType = () -> (Int, Int, Int, Int, Int) +# 266| getBody(): [BraceStmt] { ... } +# 267| getElement(0): [PatternBindingDecl] var ... = ... +# 267| getInit(0): [ArrayExpr] [...] +# 267| getElement(0): [IntegerLiteralExpr] 0 +# 267| getElement(1): [IntegerLiteralExpr] 1 +# 267| getElement(2): [IntegerLiteralExpr] 2 +# 267| getElement(3): [IntegerLiteralExpr] 3 +# 267| getElement(4): [IntegerLiteralExpr] 4 +# 267| getElement(5): [IntegerLiteralExpr] 5 +# 267| getElement(6): [IntegerLiteralExpr] 6 +# 267| getElement(7): [IntegerLiteralExpr] 7 +# 267| getElement(8): [IntegerLiteralExpr] 8 +# 267| getElement(9): [IntegerLiteralExpr] 9 +# 267| getElement(10): [IntegerLiteralExpr] 10 +# 267| getPattern(0): [NamedPattern] a +# 267| getElement(1): [ConcreteVarDecl] a +# 267| Type = [Int] +# 268| getElement(2): [AssignExpr] ... = ... +# 268| getDest(): [SubscriptExpr] ...[...] +# 268| getBase(): [InOutExpr] &... +# 268| getSubExpr(): [DeclRefExpr] a +# 268| getArgument(0): [Argument] : 0 +# 268| getExpr(): [IntegerLiteralExpr] 0 +# 268| getSource(): [IntegerLiteralExpr] 0 +# 269| getElement(3): [BinaryExpr] ... .+=(_:_:) ... +# 269| getFunction(): [MethodRefExpr] .+=(_:_:) +# 269| getBase(): [TypeExpr] Int.Type +# 269| getTypeRepr(): [TypeRepr] Int +# 269| getArgument(0): [Argument] : &... +# 269| getExpr(): [InOutExpr] &... +# 269| getSubExpr(): [SubscriptExpr] ...[...] +# 269| getBase(): [InOutExpr] &... +# 269| getSubExpr(): [DeclRefExpr] a +# 269| getArgument(0): [Argument] : 1 +# 269| getExpr(): [IntegerLiteralExpr] 1 +# 269| getArgument(1): [Argument] : 1 +# 269| getExpr(): [IntegerLiteralExpr] 1 +# 270| getElement(4): [BinaryExpr] ... .-=(_:_:) ... +# 270| getFunction(): [MethodRefExpr] .-=(_:_:) +# 270| getBase(): [TypeExpr] Int.Type +# 270| getTypeRepr(): [TypeRepr] Int +# 270| getArgument(0): [Argument] : &... +# 270| getExpr(): [InOutExpr] &... +# 270| getSubExpr(): [SubscriptExpr] ...[...] +# 270| getBase(): [InOutExpr] &... +# 270| getSubExpr(): [DeclRefExpr] a +# 270| getArgument(0): [Argument] : 2 +# 270| getExpr(): [IntegerLiteralExpr] 2 +# 270| getArgument(1): [Argument] : 1 +# 270| getExpr(): [IntegerLiteralExpr] 1 +# 271| getElement(5): [BinaryExpr] ... .*=(_:_:) ... +# 271| getFunction(): [MethodRefExpr] .*=(_:_:) +# 271| getBase(): [TypeExpr] Int.Type +# 271| getTypeRepr(): [TypeRepr] Int +# 271| getArgument(0): [Argument] : &... +# 271| getExpr(): [InOutExpr] &... +# 271| getSubExpr(): [SubscriptExpr] ...[...] +# 271| getBase(): [InOutExpr] &... +# 271| getSubExpr(): [DeclRefExpr] a +# 271| getArgument(0): [Argument] : 3 +# 271| getExpr(): [IntegerLiteralExpr] 3 +# 271| getArgument(1): [Argument] : 1 +# 271| getExpr(): [IntegerLiteralExpr] 1 +# 272| getElement(6): [BinaryExpr] ... ./=(_:_:) ... +# 272| getFunction(): [MethodRefExpr] ./=(_:_:) +# 272| getBase(): [TypeExpr] Int.Type +# 272| getTypeRepr(): [TypeRepr] Int +# 272| getArgument(0): [Argument] : &... +# 272| getExpr(): [InOutExpr] &... +# 272| getSubExpr(): [SubscriptExpr] ...[...] +# 272| getBase(): [InOutExpr] &... +# 272| getSubExpr(): [DeclRefExpr] a +# 272| getArgument(0): [Argument] : 4 +# 272| getExpr(): [IntegerLiteralExpr] 4 +# 272| getArgument(1): [Argument] : 1 +# 272| getExpr(): [IntegerLiteralExpr] 1 +# 273| getElement(7): [BinaryExpr] ... .%=(_:_:) ... +# 273| getFunction(): [MethodRefExpr] .%=(_:_:) +# 273| getBase(): [TypeExpr] Int.Type +# 273| getTypeRepr(): [TypeRepr] Int +# 273| getArgument(0): [Argument] : &... +# 273| getExpr(): [InOutExpr] &... +# 273| getSubExpr(): [SubscriptExpr] ...[...] +# 273| getBase(): [InOutExpr] &... +# 273| getSubExpr(): [DeclRefExpr] a +# 273| getArgument(0): [Argument] : 5 +# 273| getExpr(): [IntegerLiteralExpr] 5 +# 273| getArgument(1): [Argument] : 1 +# 273| getExpr(): [IntegerLiteralExpr] 1 +# 274| getElement(8): [BinaryExpr] ... .&=(_:_:) ... +# 274| getFunction(): [MethodRefExpr] .&=(_:_:) +# 274| getBase(): [TypeExpr] Int.Type +# 274| getTypeRepr(): [TypeRepr] Int +# 274| getArgument(0): [Argument] : &... +# 274| getExpr(): [InOutExpr] &... +# 274| getSubExpr(): [SubscriptExpr] ...[...] +# 274| getBase(): [InOutExpr] &... +# 274| getSubExpr(): [DeclRefExpr] a +# 274| getArgument(0): [Argument] : 6 +# 274| getExpr(): [IntegerLiteralExpr] 6 +# 274| getArgument(1): [Argument] : 1 +# 274| getExpr(): [IntegerLiteralExpr] 1 +# 275| getElement(9): [BinaryExpr] ... .|=(_:_:) ... +# 275| getFunction(): [MethodRefExpr] .|=(_:_:) +# 275| getBase(): [TypeExpr] Int.Type +# 275| getTypeRepr(): [TypeRepr] Int +# 275| getArgument(0): [Argument] : &... +# 275| getExpr(): [InOutExpr] &... +# 275| getSubExpr(): [SubscriptExpr] ...[...] +# 275| getBase(): [InOutExpr] &... +# 275| getSubExpr(): [DeclRefExpr] a +# 275| getArgument(0): [Argument] : 7 +# 275| getExpr(): [IntegerLiteralExpr] 7 +# 275| getArgument(1): [Argument] : 1 +# 275| getExpr(): [IntegerLiteralExpr] 1 +# 276| getElement(10): [BinaryExpr] ... .^=(_:_:) ... +# 276| getFunction(): [MethodRefExpr] .^=(_:_:) +# 276| getBase(): [TypeExpr] Int.Type +# 276| getTypeRepr(): [TypeRepr] Int +# 276| getArgument(0): [Argument] : &... +# 276| getExpr(): [InOutExpr] &... +# 276| getSubExpr(): [SubscriptExpr] ...[...] +# 276| getBase(): [InOutExpr] &... +# 276| getSubExpr(): [DeclRefExpr] a +# 276| getArgument(0): [Argument] : 8 +# 276| getExpr(): [IntegerLiteralExpr] 8 +# 276| getArgument(1): [Argument] : 1 +# 276| getExpr(): [IntegerLiteralExpr] 1 +# 277| getElement(11): [BinaryExpr] ... .<<=(_:_:) ... +# 277| getFunction(): [MethodRefExpr] .<<=(_:_:) +# 277| getBase(): [TypeExpr] Int.Type +# 277| getTypeRepr(): [TypeRepr] Int +# 277| getArgument(0): [Argument] : &... +# 277| getExpr(): [InOutExpr] &... +# 277| getSubExpr(): [SubscriptExpr] ...[...] +# 277| getBase(): [InOutExpr] &... +# 277| getSubExpr(): [DeclRefExpr] a +# 277| getArgument(0): [Argument] : 9 +# 277| getExpr(): [IntegerLiteralExpr] 9 +# 277| getArgument(1): [Argument] : 1 +# 277| getExpr(): [IntegerLiteralExpr] 1 +# 278| getElement(12): [BinaryExpr] ... .>>=(_:_:) ... +# 278| getFunction(): [MethodRefExpr] .>>=(_:_:) +# 278| getBase(): [TypeExpr] Int.Type +# 278| getTypeRepr(): [TypeRepr] Int +# 278| getArgument(0): [Argument] : &... +# 278| getExpr(): [InOutExpr] &... +# 278| getSubExpr(): [SubscriptExpr] ...[...] +# 278| getBase(): [InOutExpr] &... +# 278| getSubExpr(): [DeclRefExpr] a +# 278| getArgument(0): [Argument] : 10 +# 278| getExpr(): [IntegerLiteralExpr] 10 +# 278| getArgument(1): [Argument] : 1 +# 278| getExpr(): [IntegerLiteralExpr] 1 +# 280| getElement(13): [PatternBindingDecl] var ... = ... +# 280| getInit(0): [TupleExpr] (...) +# 280| getElement(0): [SubscriptExpr] ...[...] +# 280| getBase(): [InOutExpr] &... +# 280| getSubExpr(): [DeclRefExpr] a +# 280| getArgument(0): [Argument] : 0 +# 280| getExpr(): [IntegerLiteralExpr] 0 +# 280| getElement(0).getFullyConverted(): [LoadExpr] (Int) ... +# 280| getElement(1): [SubscriptExpr] ...[...] +# 280| getBase(): [InOutExpr] &... +# 280| getSubExpr(): [DeclRefExpr] a +# 280| getArgument(0): [Argument] : 1 +# 280| getExpr(): [IntegerLiteralExpr] 1 +# 280| getElement(1).getFullyConverted(): [LoadExpr] (Int) ... +# 280| getElement(2): [SubscriptExpr] ...[...] +# 280| getBase(): [InOutExpr] &... +# 280| getSubExpr(): [DeclRefExpr] a +# 280| getArgument(0): [Argument] : 2 +# 280| getExpr(): [IntegerLiteralExpr] 2 +# 280| getElement(2).getFullyConverted(): [LoadExpr] (Int) ... +# 280| getElement(3): [SubscriptExpr] ...[...] +# 280| getBase(): [InOutExpr] &... +# 280| getSubExpr(): [DeclRefExpr] a +# 280| getArgument(0): [Argument] : 3 +# 280| getExpr(): [IntegerLiteralExpr] 3 +# 280| getElement(3).getFullyConverted(): [LoadExpr] (Int) ... +# 280| getElement(4): [SubscriptExpr] ...[...] +# 280| getBase(): [InOutExpr] &... +# 280| getSubExpr(): [DeclRefExpr] a +# 280| getArgument(0): [Argument] : 4 +# 280| getExpr(): [IntegerLiteralExpr] 4 +# 280| getElement(4).getFullyConverted(): [LoadExpr] (Int) ... +# 280| getPattern(0): [NamedPattern] tupleWithA +# 280| getElement(14): [ConcreteVarDecl] tupleWithA +# 280| Type = (Int, Int, Int, Int, Int) +# 282| getElement(15): [PatternBindingDecl] var ... = ... +# 282| getInit(0): [ArrayExpr] [...] +# 282| getElement(0): [IntegerLiteralExpr] 0 +# 282| getElement(1): [IntegerLiteralExpr] 1 +# 282| getElement(2): [IntegerLiteralExpr] 2 +# 282| getElement(3): [IntegerLiteralExpr] 3 +# 282| getElement(4): [IntegerLiteralExpr] 4 +# 282| getElement(5): [IntegerLiteralExpr] 5 +# 282| getElement(6): [IntegerLiteralExpr] 6 +# 282| getElement(7): [IntegerLiteralExpr] 7 +# 282| getElement(8): [IntegerLiteralExpr] 8 +# 282| getElement(9): [IntegerLiteralExpr] 9 +# 282| getElement(10): [IntegerLiteralExpr] 10 +# 282| getElement(11): [IntegerLiteralExpr] 11 +# 282| getPattern(0): [NamedPattern] b +# 282| getElement(16): [ConcreteVarDecl] b +# 282| Type = [Int] +# 283| getElement(17): [AssignExpr] ... = ... +# 283| getDest(): [SubscriptExpr] ...[...] +# 283| getBase(): [InOutExpr] &... +# 283| getSubExpr(): [DeclRefExpr] b +# 283| getArgument(0): [Argument] : 0 +# 283| getExpr(): [IntegerLiteralExpr] 0 +# 283| getSource(): [SubscriptExpr] ...[...] +# 283| getBase(): [InOutExpr] &... +# 283| getSubExpr(): [DeclRefExpr] a +# 283| getArgument(0): [Argument] : 10 +# 283| getExpr(): [IntegerLiteralExpr] 10 +# 283| getSource().getFullyConverted(): [LoadExpr] (Int) ... +# 284| getElement(18): [AssignExpr] ... = ... +# 284| getDest(): [SubscriptExpr] ...[...] +# 284| getBase(): [InOutExpr] &... +# 284| getSubExpr(): [DeclRefExpr] b +# 284| getArgument(0): [Argument] : 1 +# 284| getExpr(): [IntegerLiteralExpr] 1 +# 284| getSource(): [BinaryExpr] ... .+(_:_:) ... +# 284| getFunction(): [MethodRefExpr] .+(_:_:) +# 284| getBase(): [TypeExpr] Int.Type +# 284| getTypeRepr(): [TypeRepr] Int +# 284| getArgument(0): [Argument] : ...[...] +# 284| getExpr(): [SubscriptExpr] ...[...] +# 284| getBase(): [InOutExpr] &... +# 284| getSubExpr(): [DeclRefExpr] b +# 284| getArgument(0): [Argument] : 0 +# 284| getExpr(): [IntegerLiteralExpr] 0 +# 284| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 284| getArgument(1): [Argument] : 1 +# 284| getExpr(): [IntegerLiteralExpr] 1 +# 285| getElement(19): [AssignExpr] ... = ... +# 285| getDest(): [SubscriptExpr] ...[...] +# 285| getBase(): [InOutExpr] &... +# 285| getSubExpr(): [DeclRefExpr] b +# 285| getArgument(0): [Argument] : 2 +# 285| getExpr(): [IntegerLiteralExpr] 2 +# 285| getSource(): [BinaryExpr] ... .-(_:_:) ... +# 285| getFunction(): [MethodRefExpr] .-(_:_:) +# 285| getBase(): [TypeExpr] Int.Type +# 285| getTypeRepr(): [TypeRepr] Int +# 285| getArgument(0): [Argument] : ...[...] +# 285| getExpr(): [SubscriptExpr] ...[...] +# 285| getBase(): [InOutExpr] &... +# 285| getSubExpr(): [DeclRefExpr] b +# 285| getArgument(0): [Argument] : 1 +# 285| getExpr(): [IntegerLiteralExpr] 1 +# 285| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 285| getArgument(1): [Argument] : 1 +# 285| getExpr(): [IntegerLiteralExpr] 1 +# 286| getElement(20): [AssignExpr] ... = ... +# 286| getDest(): [SubscriptExpr] ...[...] +# 286| getBase(): [InOutExpr] &... +# 286| getSubExpr(): [DeclRefExpr] b +# 286| getArgument(0): [Argument] : 3 +# 286| getExpr(): [IntegerLiteralExpr] 3 +# 286| getSource(): [BinaryExpr] ... .*(_:_:) ... +# 286| getFunction(): [MethodRefExpr] .*(_:_:) +# 286| getBase(): [TypeExpr] Int.Type +# 286| getTypeRepr(): [TypeRepr] Int +# 286| getArgument(0): [Argument] : ...[...] +# 286| getExpr(): [SubscriptExpr] ...[...] +# 286| getBase(): [InOutExpr] &... +# 286| getSubExpr(): [DeclRefExpr] b +# 286| getArgument(0): [Argument] : 2 +# 286| getExpr(): [IntegerLiteralExpr] 2 +# 286| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 286| getArgument(1): [Argument] : 1 +# 286| getExpr(): [IntegerLiteralExpr] 1 +# 287| getElement(21): [AssignExpr] ... = ... +# 287| getDest(): [SubscriptExpr] ...[...] +# 287| getBase(): [InOutExpr] &... +# 287| getSubExpr(): [DeclRefExpr] b +# 287| getArgument(0): [Argument] : 4 +# 287| getExpr(): [IntegerLiteralExpr] 4 +# 287| getSource(): [BinaryExpr] ... ./(_:_:) ... +# 287| getFunction(): [MethodRefExpr] ./(_:_:) +# 287| getBase(): [TypeExpr] Int.Type +# 287| getTypeRepr(): [TypeRepr] Int +# 287| getArgument(0): [Argument] : ...[...] +# 287| getExpr(): [SubscriptExpr] ...[...] +# 287| getBase(): [InOutExpr] &... +# 287| getSubExpr(): [DeclRefExpr] b +# 287| getArgument(0): [Argument] : 3 +# 287| getExpr(): [IntegerLiteralExpr] 3 +# 287| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 287| getArgument(1): [Argument] : 1 +# 287| getExpr(): [IntegerLiteralExpr] 1 +# 288| getElement(22): [AssignExpr] ... = ... +# 288| getDest(): [SubscriptExpr] ...[...] +# 288| getBase(): [InOutExpr] &... +# 288| getSubExpr(): [DeclRefExpr] b +# 288| getArgument(0): [Argument] : 5 +# 288| getExpr(): [IntegerLiteralExpr] 5 +# 288| getSource(): [BinaryExpr] ... .%(_:_:) ... +# 288| getFunction(): [MethodRefExpr] .%(_:_:) +# 288| getBase(): [TypeExpr] Int.Type +# 288| getTypeRepr(): [TypeRepr] Int +# 288| getArgument(0): [Argument] : ...[...] +# 288| getExpr(): [SubscriptExpr] ...[...] +# 288| getBase(): [InOutExpr] &... +# 288| getSubExpr(): [DeclRefExpr] b +# 288| getArgument(0): [Argument] : 4 +# 288| getExpr(): [IntegerLiteralExpr] 4 +# 288| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 288| getArgument(1): [Argument] : 1 +# 288| getExpr(): [IntegerLiteralExpr] 1 +# 289| getElement(23): [AssignExpr] ... = ... +# 289| getDest(): [SubscriptExpr] ...[...] +# 289| getBase(): [InOutExpr] &... +# 289| getSubExpr(): [DeclRefExpr] b +# 289| getArgument(0): [Argument] : 6 +# 289| getExpr(): [IntegerLiteralExpr] 6 +# 289| getSource(): [BinaryExpr] ... .&(_:_:) ... +# 289| getFunction(): [MethodRefExpr] .&(_:_:) +# 289| getBase(): [TypeExpr] Int.Type +# 289| getTypeRepr(): [TypeRepr] Int +# 289| getArgument(0): [Argument] : ...[...] +# 289| getExpr(): [SubscriptExpr] ...[...] +# 289| getBase(): [InOutExpr] &... +# 289| getSubExpr(): [DeclRefExpr] b +# 289| getArgument(0): [Argument] : 5 +# 289| getExpr(): [IntegerLiteralExpr] 5 +# 289| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 289| getArgument(1): [Argument] : 1 +# 289| getExpr(): [IntegerLiteralExpr] 1 +# 290| getElement(24): [AssignExpr] ... = ... +# 290| getDest(): [SubscriptExpr] ...[...] +# 290| getBase(): [InOutExpr] &... +# 290| getSubExpr(): [DeclRefExpr] b +# 290| getArgument(0): [Argument] : 7 +# 290| getExpr(): [IntegerLiteralExpr] 7 +# 290| getSource(): [BinaryExpr] ... .|(_:_:) ... +# 290| getFunction(): [MethodRefExpr] .|(_:_:) +# 290| getBase(): [TypeExpr] Int.Type +# 290| getTypeRepr(): [TypeRepr] Int +# 290| getArgument(0): [Argument] : ...[...] +# 290| getExpr(): [SubscriptExpr] ...[...] +# 290| getBase(): [InOutExpr] &... +# 290| getSubExpr(): [DeclRefExpr] b +# 290| getArgument(0): [Argument] : 6 +# 290| getExpr(): [IntegerLiteralExpr] 6 +# 290| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 290| getArgument(1): [Argument] : 1 +# 290| getExpr(): [IntegerLiteralExpr] 1 +# 291| getElement(25): [AssignExpr] ... = ... +# 291| getDest(): [SubscriptExpr] ...[...] +# 291| getBase(): [InOutExpr] &... +# 291| getSubExpr(): [DeclRefExpr] b +# 291| getArgument(0): [Argument] : 8 +# 291| getExpr(): [IntegerLiteralExpr] 8 +# 291| getSource(): [BinaryExpr] ... .^(_:_:) ... +# 291| getFunction(): [MethodRefExpr] .^(_:_:) +# 291| getBase(): [TypeExpr] Int.Type +# 291| getTypeRepr(): [TypeRepr] Int +# 291| getArgument(0): [Argument] : ...[...] +# 291| getExpr(): [SubscriptExpr] ...[...] +# 291| getBase(): [InOutExpr] &... +# 291| getSubExpr(): [DeclRefExpr] b +# 291| getArgument(0): [Argument] : 7 +# 291| getExpr(): [IntegerLiteralExpr] 7 +# 291| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 291| getArgument(1): [Argument] : 1 +# 291| getExpr(): [IntegerLiteralExpr] 1 +# 292| getElement(26): [AssignExpr] ... = ... +# 292| getDest(): [SubscriptExpr] ...[...] +# 292| getBase(): [InOutExpr] &... +# 292| getSubExpr(): [DeclRefExpr] b +# 292| getArgument(0): [Argument] : 9 +# 292| getExpr(): [IntegerLiteralExpr] 9 +# 292| getSource(): [BinaryExpr] ... .<<(_:_:) ... +# 292| getFunction(): [MethodRefExpr] .<<(_:_:) +# 292| getBase(): [TypeExpr] Int.Type +# 292| getTypeRepr(): [TypeRepr] Int +# 292| getArgument(0): [Argument] : ...[...] +# 292| getExpr(): [SubscriptExpr] ...[...] +# 292| getBase(): [InOutExpr] &... +# 292| getSubExpr(): [DeclRefExpr] b +# 292| getArgument(0): [Argument] : 8 +# 292| getExpr(): [IntegerLiteralExpr] 8 +# 292| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 292| getArgument(1): [Argument] : 1 +# 292| getExpr(): [IntegerLiteralExpr] 1 +# 293| getElement(27): [AssignExpr] ... = ... +# 293| getDest(): [SubscriptExpr] ...[...] +# 293| getBase(): [InOutExpr] &... +# 293| getSubExpr(): [DeclRefExpr] b +# 293| getArgument(0): [Argument] : 10 +# 293| getExpr(): [IntegerLiteralExpr] 10 +# 293| getSource(): [BinaryExpr] ... .>>(_:_:) ... +# 293| getFunction(): [MethodRefExpr] .>>(_:_:) +# 293| getBase(): [TypeExpr] Int.Type +# 293| getTypeRepr(): [TypeRepr] Int +# 293| getArgument(0): [Argument] : ...[...] +# 293| getExpr(): [SubscriptExpr] ...[...] +# 293| getBase(): [InOutExpr] &... +# 293| getSubExpr(): [DeclRefExpr] b +# 293| getArgument(0): [Argument] : 9 +# 293| getExpr(): [IntegerLiteralExpr] 9 +# 293| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 293| getArgument(1): [Argument] : 1 +# 293| getExpr(): [IntegerLiteralExpr] 1 +# 295| getElement(28): [PatternBindingDecl] var ... = ... +# 295| getInit(0): [DeclRefExpr] tupleWithA +# 295| getInit(0).getFullyConverted(): [LoadExpr] ((Int, Int, Int, Int, Int)) ... +# 295| getPattern(0): [TuplePattern] (...) +# 295| getElement(0): [NamedPattern] a1 +# 295| getElement(1): [NamedPattern] a2 +# 295| getElement(2): [NamedPattern] a3 +# 295| getElement(3): [NamedPattern] a4 +# 295| getElement(4): [NamedPattern] a5 +# 295| getElement(29): [ConcreteVarDecl] a1 +# 295| Type = Int +# 295| getElement(30): [ConcreteVarDecl] a2 +# 295| Type = Int +# 295| getElement(31): [ConcreteVarDecl] a3 +# 295| Type = Int +# 295| getElement(32): [ConcreteVarDecl] a4 +# 295| Type = Int +# 295| getElement(33): [ConcreteVarDecl] a5 +# 295| Type = Int +# 296| getElement(34): [ReturnStmt] return ... +# 296| getResult(): [TupleExpr] (...) +# 296| getElement(0): [BinaryExpr] ... .+(_:_:) ... +# 296| getFunction(): [MethodRefExpr] .+(_:_:) +# 296| getBase(): [TypeExpr] Int.Type +# 296| getTypeRepr(): [TypeRepr] Int +# 296| getArgument(0): [Argument] : a1 +# 296| getExpr(): [DeclRefExpr] a1 +# 296| getArgument(1): [Argument] : ...[...] +# 296| getExpr(): [SubscriptExpr] ...[...] +# 296| getBase(): [InOutExpr] &... +# 296| getSubExpr(): [DeclRefExpr] b +# 296| getArgument(0): [Argument] : 0 +# 296| getExpr(): [IntegerLiteralExpr] 0 +# 296| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 296| getElement(1): [BinaryExpr] ... .+(_:_:) ... +# 296| getFunction(): [MethodRefExpr] .+(_:_:) +# 296| getBase(): [TypeExpr] Int.Type +# 296| getTypeRepr(): [TypeRepr] Int +# 296| getArgument(0): [Argument] : a2 +# 296| getExpr(): [DeclRefExpr] a2 +# 296| getArgument(1): [Argument] : ...[...] +# 296| getExpr(): [SubscriptExpr] ...[...] +# 296| getBase(): [InOutExpr] &... +# 296| getSubExpr(): [DeclRefExpr] b +# 296| getArgument(0): [Argument] : 1 +# 296| getExpr(): [IntegerLiteralExpr] 1 +# 296| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 296| getElement(2): [BinaryExpr] ... .+(_:_:) ... +# 296| getFunction(): [MethodRefExpr] .+(_:_:) +# 296| getBase(): [TypeExpr] Int.Type +# 296| getTypeRepr(): [TypeRepr] Int +# 296| getArgument(0): [Argument] : a3 +# 296| getExpr(): [DeclRefExpr] a3 +# 296| getArgument(1): [Argument] : ...[...] +# 296| getExpr(): [SubscriptExpr] ...[...] +# 296| getBase(): [InOutExpr] &... +# 296| getSubExpr(): [DeclRefExpr] b +# 296| getArgument(0): [Argument] : 2 +# 296| getExpr(): [IntegerLiteralExpr] 2 +# 296| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 296| getElement(3): [BinaryExpr] ... .+(_:_:) ... +# 296| getFunction(): [MethodRefExpr] .+(_:_:) +# 296| getBase(): [TypeExpr] Int.Type +# 296| getTypeRepr(): [TypeRepr] Int +# 296| getArgument(0): [Argument] : a4 +# 296| getExpr(): [DeclRefExpr] a4 +# 296| getArgument(1): [Argument] : ...[...] +# 296| getExpr(): [SubscriptExpr] ...[...] +# 296| getBase(): [InOutExpr] &... +# 296| getSubExpr(): [DeclRefExpr] b +# 296| getArgument(0): [Argument] : 3 +# 296| getExpr(): [IntegerLiteralExpr] 3 +# 296| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 296| getElement(4): [BinaryExpr] ... .+(_:_:) ... +# 296| getFunction(): [MethodRefExpr] .+(_:_:) +# 296| getBase(): [TypeExpr] Int.Type +# 296| getTypeRepr(): [TypeRepr] Int +# 296| getArgument(0): [Argument] : a5 +# 296| getExpr(): [DeclRefExpr] a5 +# 296| getArgument(1): [Argument] : ...[...] +# 296| getExpr(): [SubscriptExpr] ...[...] +# 296| getBase(): [InOutExpr] &... +# 296| getSubExpr(): [DeclRefExpr] b +# 296| getArgument(0): [Argument] : 4 +# 296| getExpr(): [IntegerLiteralExpr] 4 +# 296| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 299| [ConcreteFuncDecl] loop1(x:) +# 299| InterfaceType = (inout Int) -> () +# 299| getParam(0): [ParamDecl] x +# 299| Type = Int +# 299| getBody(): [BraceStmt] { ... } +# 300| getElement(0): [WhileStmt] while ... { ... } +# 300| getCondition(): [StmtCondition] StmtCondition +# 300| getElement(0): [ConditionElement] ... .>=(_:_:) ... +# 300| getBoolean(): [BinaryExpr] ... .>=(_:_:) ... +# 300| getFunction(): [MethodRefExpr] .>=(_:_:) +# 300| getBase(): [TypeExpr] Int.Type +# 300| getTypeRepr(): [TypeRepr] Int +# 300| getArgument(0): [Argument] : x +# 300| getExpr(): [DeclRefExpr] x +# 300| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 300| getArgument(1): [Argument] : 0 +# 300| getExpr(): [IntegerLiteralExpr] 0 +# 300| getBody(): [BraceStmt] { ... } +# 301| getElement(0): [CallExpr] call to print(_:separator:terminator:) +# 301| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 301| getArgument(0): [Argument] : [...] +# 301| getExpr(): [VarargExpansionExpr] [...] +# 301| getSubExpr(): [ArrayExpr] [...] +# 301| getElement(0): [DeclRefExpr] x +# 301| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 301| getImmediateSubExpr(): [LoadExpr] (Int) ... +# 301| getArgument(1): [Argument] separator: default separator +# 301| getExpr(): [DefaultArgumentExpr] default separator +# 301| getArgument(2): [Argument] terminator: default terminator +# 301| getExpr(): [DefaultArgumentExpr] default terminator +# 302| getElement(1): [BinaryExpr] ... .-=(_:_:) ... +# 302| getFunction(): [MethodRefExpr] .-=(_:_:) +# 302| getBase(): [TypeExpr] Int.Type +# 302| getTypeRepr(): [TypeRepr] Int +# 302| getArgument(0): [Argument] : &... +# 302| getExpr(): [InOutExpr] &... +# 302| getSubExpr(): [DeclRefExpr] x +# 302| getArgument(1): [Argument] : 1 +# 302| getExpr(): [IntegerLiteralExpr] 1 +# 306| [ConcreteFuncDecl] loop2(x:) +# 306| InterfaceType = (inout Int) -> () +# 306| getParam(0): [ParamDecl] x +# 306| Type = Int +# 306| getBody(): [BraceStmt] { ... } +# 307| getElement(0): [WhileStmt] while ... { ... } +# 307| getCondition(): [StmtCondition] StmtCondition +# 307| getElement(0): [ConditionElement] ... .>=(_:_:) ... +# 307| getBoolean(): [BinaryExpr] ... .>=(_:_:) ... +# 307| getFunction(): [MethodRefExpr] .>=(_:_:) +# 307| getBase(): [TypeExpr] Int.Type +# 307| getTypeRepr(): [TypeRepr] Int +# 307| getArgument(0): [Argument] : x +# 307| getExpr(): [DeclRefExpr] x +# 307| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 307| getArgument(1): [Argument] : 0 +# 307| getExpr(): [IntegerLiteralExpr] 0 +# 307| getBody(): [BraceStmt] { ... } +# 308| getElement(0): [CallExpr] call to print(_:separator:terminator:) +# 308| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 308| getArgument(0): [Argument] : [...] +# 308| getExpr(): [VarargExpansionExpr] [...] +# 308| getSubExpr(): [ArrayExpr] [...] +# 308| getElement(0): [DeclRefExpr] x +# 308| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 308| getImmediateSubExpr(): [LoadExpr] (Int) ... +# 308| getArgument(1): [Argument] separator: default separator +# 308| getExpr(): [DefaultArgumentExpr] default separator +# 308| getArgument(2): [Argument] terminator: default terminator +# 308| getExpr(): [DefaultArgumentExpr] default terminator +# 309| getElement(1): [BinaryExpr] ... .-=(_:_:) ... +# 309| getFunction(): [MethodRefExpr] .-=(_:_:) +# 309| getBase(): [TypeExpr] Int.Type +# 309| getTypeRepr(): [TypeRepr] Int +# 309| getArgument(0): [Argument] : &... +# 309| getExpr(): [InOutExpr] &... +# 309| getSubExpr(): [DeclRefExpr] x +# 309| getArgument(1): [Argument] : 1 +# 309| getExpr(): [IntegerLiteralExpr] 1 +# 310| getElement(2): [IfStmt] if ... then { ... } else { ... } +# 310| getCondition(): [StmtCondition] StmtCondition +# 310| getElement(0): [ConditionElement] ... .>(_:_:) ... +# 310| getBoolean(): [BinaryExpr] ... .>(_:_:) ... +# 310| getFunction(): [MethodRefExpr] .>(_:_:) +# 310| getBase(): [TypeExpr] Int.Type +# 310| getTypeRepr(): [TypeRepr] Int +# 310| getArgument(0): [Argument] : x +# 310| getExpr(): [DeclRefExpr] x +# 310| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 310| getArgument(1): [Argument] : 100 +# 310| getExpr(): [IntegerLiteralExpr] 100 +# 310| getThen(): [BraceStmt] { ... } +# 311| getElement(0): [BreakStmt] break +# 313| getElse(): [IfStmt] if ... then { ... } +# 313| getCondition(): [StmtCondition] StmtCondition +# 313| getElement(0): [ConditionElement] ... .>(_:_:) ... +# 313| getBoolean(): [BinaryExpr] ... .>(_:_:) ... +# 313| getFunction(): [MethodRefExpr] .>(_:_:) +# 313| getBase(): [TypeExpr] Int.Type +# 313| getTypeRepr(): [TypeRepr] Int +# 313| getArgument(0): [Argument] : x +# 313| getExpr(): [DeclRefExpr] x +# 313| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 313| getArgument(1): [Argument] : 50 +# 313| getExpr(): [IntegerLiteralExpr] 50 +# 313| getThen(): [BraceStmt] { ... } +# 314| getElement(0): [ContinueStmt] continue +# 316| getElement(3): [CallExpr] call to print(_:separator:terminator:) +# 316| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 316| getArgument(0): [Argument] : [...] +# 316| getExpr(): [VarargExpansionExpr] [...] +# 316| getSubExpr(): [ArrayExpr] [...] +# 316| getElement(0): [StringLiteralExpr] Iter +# 316| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 316| getArgument(1): [Argument] separator: default separator +# 316| getExpr(): [DefaultArgumentExpr] default separator +# 316| getArgument(2): [Argument] terminator: default terminator +# 316| getExpr(): [DefaultArgumentExpr] default terminator +# 318| getElement(1): [CallExpr] call to print(_:separator:terminator:) +# 318| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 318| getArgument(0): [Argument] : [...] +# 318| getExpr(): [VarargExpansionExpr] [...] +# 318| getSubExpr(): [ArrayExpr] [...] +# 318| getElement(0): [StringLiteralExpr] Done +# 318| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 318| getArgument(1): [Argument] separator: default separator +# 318| getExpr(): [DefaultArgumentExpr] default separator +# 318| getArgument(2): [Argument] terminator: default terminator +# 318| getExpr(): [DefaultArgumentExpr] default terminator +# 321| [ConcreteFuncDecl] labeledLoop(x:) +# 321| InterfaceType = (inout Int) -> () +# 321| getParam(0): [ParamDecl] x +# 321| Type = Int +# 321| getBody(): [BraceStmt] { ... } +# 322| getElement(0): [WhileStmt] while ... { ... } +# 322| getCondition(): [StmtCondition] StmtCondition +# 322| getElement(0): [ConditionElement] ... .>=(_:_:) ... +# 322| getBoolean(): [BinaryExpr] ... .>=(_:_:) ... +# 322| getFunction(): [MethodRefExpr] .>=(_:_:) +# 322| getBase(): [TypeExpr] Int.Type +# 322| getTypeRepr(): [TypeRepr] Int +# 322| getArgument(0): [Argument] : x +# 322| getExpr(): [DeclRefExpr] x +# 322| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 322| getArgument(1): [Argument] : 0 +# 322| getExpr(): [IntegerLiteralExpr] 0 +# 322| getBody(): [BraceStmt] { ... } +# 323| getElement(0): [WhileStmt] while ... { ... } +# 323| getCondition(): [StmtCondition] StmtCondition +# 323| getElement(0): [ConditionElement] ... .>=(_:_:) ... +# 323| getBoolean(): [BinaryExpr] ... .>=(_:_:) ... +# 323| getFunction(): [MethodRefExpr] .>=(_:_:) +# 323| getBase(): [TypeExpr] Int.Type +# 323| getTypeRepr(): [TypeRepr] Int +# 323| getArgument(0): [Argument] : x +# 323| getExpr(): [DeclRefExpr] x +# 323| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 323| getArgument(1): [Argument] : 0 +# 323| getExpr(): [IntegerLiteralExpr] 0 +# 323| getBody(): [BraceStmt] { ... } +# 324| getElement(0): [CallExpr] call to print(_:separator:terminator:) +# 324| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 324| getArgument(0): [Argument] : [...] +# 324| getExpr(): [VarargExpansionExpr] [...] +# 324| getSubExpr(): [ArrayExpr] [...] +# 324| getElement(0): [DeclRefExpr] x +# 324| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 324| getImmediateSubExpr(): [LoadExpr] (Int) ... +# 324| getArgument(1): [Argument] separator: default separator +# 324| getExpr(): [DefaultArgumentExpr] default separator +# 324| getArgument(2): [Argument] terminator: default terminator +# 324| getExpr(): [DefaultArgumentExpr] default terminator +# 325| getElement(1): [BinaryExpr] ... .-=(_:_:) ... +# 325| getFunction(): [MethodRefExpr] .-=(_:_:) +# 325| getBase(): [TypeExpr] Int.Type +# 325| getTypeRepr(): [TypeRepr] Int +# 325| getArgument(0): [Argument] : &... +# 325| getExpr(): [InOutExpr] &... +# 325| getSubExpr(): [DeclRefExpr] x +# 325| getArgument(1): [Argument] : 1 +# 325| getExpr(): [IntegerLiteralExpr] 1 +# 326| getElement(2): [IfStmt] if ... then { ... } else { ... } +# 326| getCondition(): [StmtCondition] StmtCondition +# 326| getElement(0): [ConditionElement] ... .>(_:_:) ... +# 326| getBoolean(): [BinaryExpr] ... .>(_:_:) ... +# 326| getFunction(): [MethodRefExpr] .>(_:_:) +# 326| getBase(): [TypeExpr] Int.Type +# 326| getTypeRepr(): [TypeRepr] Int +# 326| getArgument(0): [Argument] : x +# 326| getExpr(): [DeclRefExpr] x +# 326| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 326| getArgument(1): [Argument] : 100 +# 326| getExpr(): [IntegerLiteralExpr] 100 +# 326| getThen(): [BraceStmt] { ... } +# 327| getElement(0): [BreakStmt] break outer +# 329| getElse(): [IfStmt] if ... then { ... } +# 329| getCondition(): [StmtCondition] StmtCondition +# 329| getElement(0): [ConditionElement] ... .>(_:_:) ... +# 329| getBoolean(): [BinaryExpr] ... .>(_:_:) ... +# 329| getFunction(): [MethodRefExpr] .>(_:_:) +# 329| getBase(): [TypeExpr] Int.Type +# 329| getTypeRepr(): [TypeRepr] Int +# 329| getArgument(0): [Argument] : x +# 329| getExpr(): [DeclRefExpr] x +# 329| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 329| getArgument(1): [Argument] : 50 +# 329| getExpr(): [IntegerLiteralExpr] 50 +# 329| getThen(): [BraceStmt] { ... } +# 330| getElement(0): [ContinueStmt] continue inner +# 332| getElement(3): [CallExpr] call to print(_:separator:terminator:) +# 332| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 332| getArgument(0): [Argument] : [...] +# 332| getExpr(): [VarargExpansionExpr] [...] +# 332| getSubExpr(): [ArrayExpr] [...] +# 332| getElement(0): [StringLiteralExpr] Iter +# 332| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 332| getArgument(1): [Argument] separator: default separator +# 332| getExpr(): [DefaultArgumentExpr] default separator +# 332| getArgument(2): [Argument] terminator: default terminator +# 332| getExpr(): [DefaultArgumentExpr] default terminator +# 334| getElement(1): [CallExpr] call to print(_:separator:terminator:) +# 334| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 334| getArgument(0): [Argument] : [...] +# 334| getExpr(): [VarargExpansionExpr] [...] +# 334| getSubExpr(): [ArrayExpr] [...] +# 334| getElement(0): [StringLiteralExpr] Done +# 334| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 334| getArgument(1): [Argument] separator: default separator +# 334| getExpr(): [DefaultArgumentExpr] default separator +# 334| getArgument(2): [Argument] terminator: default terminator +# 334| getExpr(): [DefaultArgumentExpr] default terminator +# 338| [ConcreteFuncDecl] testRepeat(x:) +# 338| InterfaceType = (inout Int) -> () +# 338| getParam(0): [ParamDecl] x +# 338| Type = Int +# 338| getBody(): [BraceStmt] { ... } +# 339| getElement(0): [RepeatWhileStmt] repeat { ... } while ... +# 342| getCondition(): [BinaryExpr] ... .>=(_:_:) ... +# 342| getFunction(): [MethodRefExpr] .>=(_:_:) +# 342| getBase(): [TypeExpr] Int.Type +# 342| getTypeRepr(): [TypeRepr] Int +# 342| getArgument(0): [Argument] : x +# 342| getExpr(): [DeclRefExpr] x +# 342| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 342| getArgument(1): [Argument] : 0 +# 342| getExpr(): [IntegerLiteralExpr] 0 +# 339| getBody(): [BraceStmt] { ... } +# 340| getElement(0): [CallExpr] call to print(_:separator:terminator:) +# 340| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 340| getArgument(0): [Argument] : [...] +# 340| getExpr(): [VarargExpansionExpr] [...] +# 340| getSubExpr(): [ArrayExpr] [...] +# 340| getElement(0): [DeclRefExpr] x +# 340| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 340| getImmediateSubExpr(): [LoadExpr] (Int) ... +# 340| getArgument(1): [Argument] separator: default separator +# 340| getExpr(): [DefaultArgumentExpr] default separator +# 340| getArgument(2): [Argument] terminator: default terminator +# 340| getExpr(): [DefaultArgumentExpr] default terminator +# 341| getElement(1): [BinaryExpr] ... .-=(_:_:) ... +# 341| getFunction(): [MethodRefExpr] .-=(_:_:) +# 341| getBase(): [TypeExpr] Int.Type +# 341| getTypeRepr(): [TypeRepr] Int +# 341| getArgument(0): [Argument] : &... +# 341| getExpr(): [InOutExpr] &... +# 341| getSubExpr(): [DeclRefExpr] x +# 341| getArgument(1): [Argument] : 1 +# 341| getExpr(): [IntegerLiteralExpr] 1 +# 345| [ConcreteFuncDecl] loop_with_identity_expr() +# 345| InterfaceType = () -> () +# 345| getBody(): [BraceStmt] { ... } +# 346| getElement(0): [PatternBindingDecl] var ... = ... +# 346| getInit(0): [IntegerLiteralExpr] 0 +# 346| getPattern(0): [NamedPattern] x +# 346| getElement(1): [ConcreteVarDecl] x +# 346| Type = Int +# 347| getElement(2): [WhileStmt] while ... { ... } +# 347| getCondition(): [StmtCondition] StmtCondition +# 347| getElement(0): [ConditionElement] ... .<(_:_:) ... +# 347| getBoolean(): [BinaryExpr] ... .<(_:_:) ... +# 347| getFunction(): [MethodRefExpr] .<(_:_:) +# 347| getBase(): [TypeExpr] Int.Type +# 347| getTypeRepr(): [TypeRepr] Int +# 347| getArgument(0): [Argument] : x +# 347| getExpr(): [DeclRefExpr] x +# 347| getExpr().getFullyConverted(): [LoadExpr] (Int) ... +# 347| getArgument(1): [Argument] : 10 +# 347| getExpr(): [IntegerLiteralExpr] 10 +# 347| getBoolean().getFullyConverted(): [ParenExpr] (...) +# 347| getBody(): [BraceStmt] { ... } +# 348| getElement(0): [BinaryExpr] ... .+=(_:_:) ... +# 348| getFunction(): [MethodRefExpr] .+=(_:_:) +# 348| getBase(): [TypeExpr] Int.Type +# 348| getTypeRepr(): [TypeRepr] Int +# 348| getArgument(0): [Argument] : &... +# 348| getExpr(): [InOutExpr] &... +# 348| getSubExpr(): [DeclRefExpr] x +# 348| getArgument(1): [Argument] : 1 +# 348| getExpr(): [IntegerLiteralExpr] 1 +# 352| [ClassDecl] OptionalC +# 353| getMember(0): [PatternBindingDecl] var ... = ... +# 353| getPattern(0): [TypedPattern] ... as ... +# 353| getSubPattern(): [NamedPattern] c +# 353| getTypeRepr(): [TypeRepr] C? +# 353| getMember(1): [ConcreteVarDecl] c +# 353| Type = C? +# 353| getAccessorDecl(0): [AccessorDecl] get +# 353| InterfaceType = (OptionalC) -> () -> C? +# 353| getSelfParam(): [ParamDecl] self +# 353| Type = OptionalC +# 353| getBody(): [BraceStmt] { ... } +# 354| getMember(2): [ConstructorDecl] init(arg:) +# 354| InterfaceType = (OptionalC.Type) -> (C?) -> OptionalC +# 354| getSelfParam(): [ParamDecl] self +# 354| Type = OptionalC +# 354| getParam(0): [ParamDecl] arg +# 354| Type = C? +# 354| getBody(): [BraceStmt] { ... } +# 355| getElement(0): [AssignExpr] ... = ... +# 355| getDest(): [MemberRefExpr] .c +# 355| getBase(): [DeclRefExpr] self +# 355| getSource(): [DeclRefExpr] arg +# 356| getElement(1): [ReturnStmt] return +# 358| getMember(3): [ConcreteFuncDecl] getOptional() +# 358| InterfaceType = (OptionalC) -> () -> C? +# 358| getSelfParam(): [ParamDecl] self +# 358| Type = OptionalC +# 358| getBody(): [BraceStmt] { ... } +# 359| getElement(0): [ReturnStmt] return ... +# 359| getResult(): [MemberRefExpr] .c +# 359| getBase(): [DeclRefExpr] self +# 352| getMember(4): [DestructorDecl] deinit() +# 352| InterfaceType = (OptionalC) -> () -> () +# 352| getSelfParam(): [ParamDecl] self +# 352| Type = OptionalC +# 352| getBody(): [BraceStmt] { ... } +# 363| [ConcreteFuncDecl] testOptional(c:) +# 363| InterfaceType = (OptionalC?) -> Int? +# 363| getParam(0): [ParamDecl] c +# 363| Type = OptionalC? +# 363| getBody(): [BraceStmt] { ... } +# 364| getElement(0): [ReturnStmt] return ... +# 364| getResult(): [OptionalEvaluationExpr] OptionalEvaluationExpr +# 364| getSubExpr(): [CallExpr] call to getMyInt() +# 364| getFunction(): [MethodRefExpr] .getMyInt() +# 364| getBase(): [BindOptionalExpr] ...? +# 364| getSubExpr(): [CallExpr] call to getOptional() +# 364| getFunction(): [MethodRefExpr] .getOptional() +# 364| getBase(): [BindOptionalExpr] ...? +# 364| getSubExpr(): [DeclRefExpr] c +# 364| getSubExpr().getFullyConverted(): [InjectIntoOptionalExpr] (Int?) ... +# 367| [ConcreteFuncDecl] testCapture(x:y:) +# 367| InterfaceType = (Int, Int) -> () -> Int +# 367| getParam(0): [ParamDecl] x +# 367| Type = Int +# 367| getParam(1): [ParamDecl] y +# 367| Type = Int +# 367| getBody(): [BraceStmt] { ... } +# 368| getElement(0): [ReturnStmt] return ... +# 368| getResult(): [CaptureListExpr] { ... } +# 368| getBindingDecl(0): [PatternBindingDecl] var ... = ... +# 368| getInit(0): [BinaryExpr] ... .+(_:_:) ... +# 368| getFunction(): [MethodRefExpr] .+(_:_:) +# 368| getBase(): [TypeExpr] Int.Type +# 368| getTypeRepr(): [TypeRepr] Int +# 368| getArgument(0): [Argument] : x +# 368| getExpr(): [DeclRefExpr] x +# 368| getArgument(1): [Argument] : y +# 368| getExpr(): [DeclRefExpr] y +# 368| getPattern(0): [NamedPattern] z +# 368| getBindingDecl(1): [PatternBindingDecl] var ... = ... +# 368| getInit(0): [StringLiteralExpr] literal +# 368| getPattern(0): [NamedPattern] t +# 368| getClosureBody(): [ClosureExpr] { ... } +# 368| getBody(): [BraceStmt] { ... } +# 369| getElement(0): [ReturnStmt] return ... +# 369| getResult(): [DeclRefExpr] z +# 368| [ConcreteVarDecl] z +# 368| Type = Int +# 373| [ConcreteFuncDecl] testTupleElement(t:) +# 373| InterfaceType = ((a: Int, Int, c: Int)) -> Int +# 373| getParam(0): [ParamDecl] t +# 373| Type = (a: Int, Int, c: Int) +# 373| getBody(): [BraceStmt] { ... } +# 374| getElement(0): [ReturnStmt] return ... +# 374| getResult(): [BinaryExpr] ... .+(_:_:) ... +# 374| getFunction(): [MethodRefExpr] .+(_:_:) +# 374| getBase(): [TypeExpr] Int.Type +# 374| getTypeRepr(): [TypeRepr] Int +# 374| getArgument(0): [Argument] : ... .+(_:_:) ... +# 374| getExpr(): [BinaryExpr] ... .+(_:_:) ... +# 374| getFunction(): [MethodRefExpr] .+(_:_:) +# 374| getBase(): [TypeExpr] Int.Type +# 374| getTypeRepr(): [TypeRepr] Int +# 374| getArgument(0): [Argument] : ... .+(_:_:) ... +# 374| getExpr(): [BinaryExpr] ... .+(_:_:) ... +# 374| getFunction(): [MethodRefExpr] .+(_:_:) +# 374| getBase(): [TypeExpr] Int.Type +# 374| getTypeRepr(): [TypeRepr] Int +# 374| getArgument(0): [Argument] : .0 +# 374| getExpr(): [TupleElementExpr] .0 +# 374| getSubExpr(): [DeclRefExpr] t +# 374| getArgument(1): [Argument] : .1 +# 374| getExpr(): [TupleElementExpr] .1 +# 374| getSubExpr(): [DeclRefExpr] t +# 374| getArgument(1): [Argument] : .2 +# 374| getExpr(): [TupleElementExpr] .2 +# 374| getSubExpr(): [DeclRefExpr] t +# 374| getArgument(1): [Argument] : .0 +# 374| getExpr(): [TupleElementExpr] .0 +# 374| getSubExpr(): [TupleExpr] (...) +# 374| getElement(0): [IntegerLiteralExpr] 1 +# 374| getElement(1): [IntegerLiteralExpr] 2 +# 374| getElement(2): [IntegerLiteralExpr] 3 +# 377| [ClassDecl] Derived +# 378| getMember(0): [ConstructorDecl] init() +# 378| InterfaceType = (Derived.Type) -> () -> Derived +# 378| getSelfParam(): [ParamDecl] self +# 378| Type = Derived +# 378| getBody(): [BraceStmt] { ... } +# 379| getElement(0): [RebindSelfInConstructorExpr] self = ... +# 379| getSubExpr(): [CallExpr] call to ... +# 379| getFunction(): [DotSyntaxCallExpr] call to ... +# 379| getFunction(): [OtherConstructorDeclRefExpr] init(n:) +# 379| getArgument(0): [Argument] : super +# 379| getExpr(): [SuperRefExpr] super +# 379| getArgument(0): [Argument] n: 0 +# 379| getExpr(): [IntegerLiteralExpr] 0 +# 380| getElement(1): [ReturnStmt] return +# 377| getMember(1): [ConstructorDecl] init(n:) +# 377| InterfaceType = (Derived.Type) -> (Int) -> Derived +# 377| getSelfParam(): [ParamDecl] self +# 377| Type = Derived +# 377| getMember(2): [DestructorDecl] deinit() +# 377| InterfaceType = (Derived) -> () -> () +# 377| getSelfParam(): [ParamDecl] self +# 377| Type = Derived +# 377| getBody(): [BraceStmt] { ... } +# 377| [CallExpr] call to _unimplementedInitializer(className:initName:file:line:column:) +# 377| getFunction(): [DeclRefExpr] _unimplementedInitializer(className:initName:file:line:column:) +# 377| getArgument(0): [Argument] : cfg.Derived +# 377| getExpr(): [StringLiteralExpr] cfg.Derived +# 377| getArgument(1): [Argument] : #... +# 377| getExpr(): [MagicIdentifierLiteralExpr] #... +# 377| getArgument(2): [Argument] : #... +# 377| getExpr(): [MagicIdentifierLiteralExpr] #... +# 377| getArgument(3): [Argument] : #... +# 377| getExpr(): [MagicIdentifierLiteralExpr] #... +# 377| getArgument(4): [Argument] : #... +# 377| getExpr(): [MagicIdentifierLiteralExpr] #... +# 383| [ConcreteFuncDecl] doWithoutCatch(x:) +# 383| InterfaceType = (Int) throws -> Int +# 383| getParam(0): [ParamDecl] x +# 383| Type = Int +# 383| getBody(): [BraceStmt] { ... } +# 384| getElement(0): [DoStmt] do { ... } +# 384| getBody(): [BraceStmt] { ... } +# 385| getElement(0): [TryExpr] try ... +# 385| getSubExpr(): [CallExpr] call to mightThrow(x:) +# 385| getFunction(): [DeclRefExpr] mightThrow(x:) +# 385| getArgument(0): [Argument] x: 0 +# 385| getExpr(): [IntegerLiteralExpr] 0 +# 386| getElement(1): [CallExpr] call to print(_:separator:terminator:) +# 386| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 386| getArgument(0): [Argument] : [...] +# 386| getExpr(): [VarargExpansionExpr] [...] +# 386| getSubExpr(): [ArrayExpr] [...] +# 386| getElement(0): [StringLiteralExpr] Did not throw. +# 386| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 386| getArgument(1): [Argument] separator: default separator +# 386| getExpr(): [DefaultArgumentExpr] default separator +# 386| getArgument(2): [Argument] terminator: default terminator +# 386| getExpr(): [DefaultArgumentExpr] default terminator +# 387| getElement(2): [ForceTryExpr] try! ... +# 387| getSubExpr(): [CallExpr] call to mightThrow(x:) +# 387| getFunction(): [DeclRefExpr] mightThrow(x:) +# 387| getArgument(0): [Argument] x: 0 +# 387| getExpr(): [IntegerLiteralExpr] 0 +# 388| getElement(3): [CallExpr] call to print(_:separator:terminator:) +# 388| getFunction(): [DeclRefExpr] print(_:separator:terminator:) +# 388| getArgument(0): [Argument] : [...] +# 388| getExpr(): [VarargExpansionExpr] [...] +# 388| getSubExpr(): [ArrayExpr] [...] +# 388| getElement(0): [StringLiteralExpr] Still did not throw. +# 388| getElement(0).getFullyConverted(): [ErasureExpr] (Any) ... +# 388| getArgument(1): [Argument] separator: default separator +# 388| getExpr(): [DefaultArgumentExpr] default separator +# 388| getArgument(2): [Argument] terminator: default terminator +# 388| getExpr(): [DefaultArgumentExpr] default terminator +# 390| getElement(1): [ReturnStmt] return ... +# 390| getResult(): [IntegerLiteralExpr] 0 +# 393| [ClassDecl] Structors +# 394| getMember(0): [PatternBindingDecl] var ... = ... +# 394| getPattern(0): [TypedPattern] ... as ... +# 394| getSubPattern(): [NamedPattern] field +# 394| getTypeRepr(): [TypeRepr] Int +# 394| getMember(1): [ConcreteVarDecl] field +# 394| Type = Int +# 394| getAccessorDecl(0): [AccessorDecl] get +# 394| InterfaceType = (Structors) -> () -> Int +# 394| getSelfParam(): [ParamDecl] self +# 394| Type = Structors +# 394| getBody(): [BraceStmt] { ... } +# 394| getAccessorDecl(1): [AccessorDecl] set +# 394| InterfaceType = (Structors) -> (Int) -> () +# 394| getSelfParam(): [ParamDecl] self +# 394| Type = Structors +# 394| getParam(0): [ParamDecl] value +# 394| Type = Int +# 394| getBody(): [BraceStmt] { ... } +# 394| getAccessorDecl(2): [AccessorDecl] (unnamed function decl) +# 394| InterfaceType = (Structors) -> () -> () +# 394| getSelfParam(): [ParamDecl] self +# 394| Type = Structors +# 394| getBody(): [BraceStmt] { ... } +# 394| getElement(0): [YieldStmt] yield ... +# 395| getMember(2): [ConstructorDecl] init() +# 395| InterfaceType = (Structors.Type) -> () -> Structors +# 395| getSelfParam(): [ParamDecl] self +# 395| Type = Structors +# 395| getBody(): [BraceStmt] { ... } +# 396| getElement(0): [AssignExpr] ... = ... +# 396| getDest(): [MemberRefExpr] .field +# 396| getBase(): [DeclRefExpr] self +# 396| getSource(): [IntegerLiteralExpr] 10 +# 397| getElement(1): [ReturnStmt] return +# 399| getMember(3): [DestructorDecl] deinit() +# 399| InterfaceType = (Structors) -> () -> () +# 399| getSelfParam(): [ParamDecl] self +# 399| Type = Structors +# 399| getBody(): [BraceStmt] { ... } +# 400| getElement(0): [AssignExpr] ... = ... +# 400| getDest(): [MemberRefExpr] .field +# 400| getBase(): [DeclRefExpr] self +# 400| getSource(): [IntegerLiteralExpr] 0 +# 404| [ConcreteFuncDecl] dictionaryLiteral(x:y:) +# 404| InterfaceType = (Int, Int) -> [String : Int] +# 404| getParam(0): [ParamDecl] x +# 404| Type = Int +# 404| getParam(1): [ParamDecl] y +# 404| Type = Int +# 404| getBody(): [BraceStmt] { ... } +# 405| getElement(0): [ReturnStmt] return ... +# 405| getResult(): [DictionaryExpr] [...] +# 405| getElement(0): [TupleExpr] (...) +# 405| getElement(0): [StringLiteralExpr] x +# 405| getElement(1): [DeclRefExpr] x +# 405| getElement(1): [TupleExpr] (...) +# 405| getElement(0): [StringLiteralExpr] y +# 405| getElement(1): [DeclRefExpr] y +# 408| [ConcreteFuncDecl] localDeclarations() +# 408| InterfaceType = () -> Int +# 408| getBody(): [BraceStmt] { ... } +# 409| getElement(0): [ClassDecl] MyLocalClass +# 410| getMember(0): [PatternBindingDecl] var ... = ... +# 410| getPattern(0): [TypedPattern] ... as ... +# 410| getSubPattern(): [NamedPattern] x +# 410| getTypeRepr(): [TypeRepr] Int +# 410| getMember(1): [ConcreteVarDecl] x +# 410| Type = Int +# 410| getAccessorDecl(0): [AccessorDecl] get +# 410| InterfaceType = (MyLocalClass) -> () -> Int +# 410| getSelfParam(): [ParamDecl] self +# 410| Type = MyLocalClass +# 410| getBody(): [BraceStmt] { ... } +# 410| getAccessorDecl(1): [AccessorDecl] set +# 410| InterfaceType = (MyLocalClass) -> (Int) -> () +# 410| getSelfParam(): [ParamDecl] self +# 410| Type = MyLocalClass +# 410| getParam(0): [ParamDecl] value +# 410| Type = Int +# 410| getBody(): [BraceStmt] { ... } +# 410| getAccessorDecl(2): [AccessorDecl] (unnamed function decl) +# 410| InterfaceType = (MyLocalClass) -> () -> () +# 410| getSelfParam(): [ParamDecl] self +# 410| Type = MyLocalClass +# 410| getBody(): [BraceStmt] { ... } +# 410| getElement(0): [YieldStmt] yield ... +# 411| getMember(2): [ConstructorDecl] init() +# 411| InterfaceType = (MyLocalClass.Type) -> () -> MyLocalClass +# 411| getSelfParam(): [ParamDecl] self +# 411| Type = MyLocalClass +# 411| getBody(): [BraceStmt] { ... } +# 412| getElement(0): [AssignExpr] ... = ... +# 412| getDest(): [MemberRefExpr] .x +# 412| getBase(): [DeclRefExpr] self +# 412| getSource(): [IntegerLiteralExpr] 10 +# 413| getElement(1): [ReturnStmt] return +# 409| getMember(3): [DestructorDecl] deinit() +# 409| InterfaceType = (MyLocalClass) -> () -> () +# 409| getSelfParam(): [ParamDecl] self +# 409| Type = MyLocalClass +# 409| getBody(): [BraceStmt] { ... } +# 416| getElement(1): [StructDecl] MyLocalStruct +# 417| getMember(0): [PatternBindingDecl] var ... = ... +# 417| getPattern(0): [TypedPattern] ... as ... +# 417| getSubPattern(): [NamedPattern] x +# 417| getTypeRepr(): [TypeRepr] Int +# 417| getMember(1): [ConcreteVarDecl] x +# 417| Type = Int +# 417| getAccessorDecl(0): [AccessorDecl] get +# 417| InterfaceType = (MyLocalStruct) -> () -> Int +# 417| getSelfParam(): [ParamDecl] self +# 417| Type = MyLocalStruct +# 417| getBody(): [BraceStmt] { ... } +# 417| getAccessorDecl(1): [AccessorDecl] set +# 417| InterfaceType = (inout MyLocalStruct) -> (Int) -> () +# 417| getSelfParam(): [ParamDecl] self +# 417| Type = MyLocalStruct +# 417| getParam(0): [ParamDecl] value +# 417| Type = Int +# 417| getBody(): [BraceStmt] { ... } +# 417| getAccessorDecl(2): [AccessorDecl] (unnamed function decl) +# 417| InterfaceType = (inout MyLocalStruct) -> () -> () +# 417| getSelfParam(): [ParamDecl] self +# 417| Type = MyLocalStruct +# 417| getBody(): [BraceStmt] { ... } +# 417| getElement(0): [YieldStmt] yield ... +# 418| getMember(2): [ConstructorDecl] init() +# 418| InterfaceType = (MyLocalStruct.Type) -> () -> MyLocalStruct +# 418| getSelfParam(): [ParamDecl] self +# 418| Type = MyLocalStruct +# 418| getBody(): [BraceStmt] { ... } +# 419| getElement(0): [AssignExpr] ... = ... +# 419| getDest(): [MemberRefExpr] .x +# 419| getBase(): [DeclRefExpr] self +# 419| getSource(): [IntegerLiteralExpr] 10 +# 420| getElement(1): [ReturnStmt] return +# 423| getElement(2): [EnumDecl] MyLocalEnum +# 424| getMember(0): [EnumCaseDecl] case ... +# 424| getMember(1): [EnumElementDecl] A +# 425| getMember(2): [EnumCaseDecl] case ... +# 425| getMember(3): [EnumElementDecl] B +# 428| getElement(3): [PatternBindingDecl] var ... = ... +# 428| getPattern(0): [TypedPattern] ... as ... +# 428| getSubPattern(): [NamedPattern] myLocalVar +# 428| getTypeRepr(): [TypeRepr] Int +# 428| getElement(4): [ConcreteVarDecl] myLocalVar +# 428| Type = Int +# 442| getElement(5): [ReturnStmt] return ... +# 442| getResult(): [IntegerLiteralExpr] 0 +# 430| [Comment] // Error: declaration is only valid at file scope +# 430| +# 431| [Comment] // extension Int { +# 431| +# 432| [Comment] // func myExtensionMethod() -> Int { +# 432| +# 433| [Comment] // return self +# 433| +# 434| [Comment] // } +# 434| +# 435| [Comment] // } +# 435| +# 437| [Comment] // protocol 'MyProtocol' cannot be nested inside another declaration +# 437| +# 438| [Comment] // protocol MyProtocol { +# 438| +# 439| [Comment] // func myMethod() +# 439| +# 440| [Comment] // } +# 440| +# 445| [StructDecl] B +# 446| getMember(0): [PatternBindingDecl] var ... = ... +# 446| getPattern(0): [TypedPattern] ... as ... +# 446| getSubPattern(): [NamedPattern] x +# 446| getTypeRepr(): [TypeRepr] Int +# 446| getMember(1): [ConcreteVarDecl] x +# 446| Type = Int +# 446| getAccessorDecl(0): [AccessorDecl] get +# 446| InterfaceType = (B) -> () -> Int +# 446| getSelfParam(): [ParamDecl] self +# 446| Type = B +# 446| getBody(): [BraceStmt] { ... } +# 446| getAccessorDecl(1): [AccessorDecl] set +# 446| InterfaceType = (inout B) -> (Int) -> () +# 446| getSelfParam(): [ParamDecl] self +# 446| Type = B +# 446| getParam(0): [ParamDecl] value +# 446| Type = Int +# 446| getBody(): [BraceStmt] { ... } +# 446| getAccessorDecl(2): [AccessorDecl] (unnamed function decl) +# 446| InterfaceType = (inout B) -> () -> () +# 446| getSelfParam(): [ParamDecl] self +# 446| Type = B +# 446| getBody(): [BraceStmt] { ... } +# 446| getElement(0): [YieldStmt] yield ... +# 445| getMember(2): [ConstructorDecl] init(x:) +# 445| InterfaceType = (B.Type) -> (Int) -> B +# 445| getSelfParam(): [ParamDecl] self +# 445| Type = B +# 445| getParam(0): [ParamDecl] x +# 445| Type = Int +# 449| [StructDecl] A +# 450| getMember(0): [PatternBindingDecl] var ... = ... +# 450| getPattern(0): [TypedPattern] ... as ... +# 450| getSubPattern(): [NamedPattern] b +# 450| getTypeRepr(): [TypeRepr] B +# 450| getMember(1): [ConcreteVarDecl] b +# 450| Type = B +# 450| getAccessorDecl(0): [AccessorDecl] get +# 450| InterfaceType = (A) -> () -> B +# 450| getSelfParam(): [ParamDecl] self +# 450| Type = A +# 450| getBody(): [BraceStmt] { ... } +# 450| getAccessorDecl(1): [AccessorDecl] set +# 450| InterfaceType = (inout A) -> (B) -> () +# 450| getSelfParam(): [ParamDecl] self +# 450| Type = A +# 450| getParam(0): [ParamDecl] value +# 450| Type = B +# 450| getBody(): [BraceStmt] { ... } +# 450| getAccessorDecl(2): [AccessorDecl] (unnamed function decl) +# 450| InterfaceType = (inout A) -> () -> () +# 450| getSelfParam(): [ParamDecl] self +# 450| Type = A +# 450| getBody(): [BraceStmt] { ... } +# 450| getElement(0): [YieldStmt] yield ... +# 451| getMember(2): [PatternBindingDecl] var ... = ... +# 451| getPattern(0): [TypedPattern] ... as ... +# 451| getSubPattern(): [NamedPattern] bs +# 451| getTypeRepr(): [TypeRepr] [B] +# 451| getMember(3): [ConcreteVarDecl] bs +# 451| Type = [B] +# 451| getAccessorDecl(0): [AccessorDecl] get +# 451| InterfaceType = (A) -> () -> [B] +# 451| getSelfParam(): [ParamDecl] self +# 451| Type = A +# 451| getBody(): [BraceStmt] { ... } +# 451| getAccessorDecl(1): [AccessorDecl] set +# 451| InterfaceType = (inout A) -> ([B]) -> () +# 451| getSelfParam(): [ParamDecl] self +# 451| Type = A +# 451| getParam(0): [ParamDecl] value +# 451| Type = [B] +# 451| getBody(): [BraceStmt] { ... } +# 451| getAccessorDecl(2): [AccessorDecl] (unnamed function decl) +# 451| InterfaceType = (inout A) -> () -> () +# 451| getSelfParam(): [ParamDecl] self +# 451| Type = A +# 451| getBody(): [BraceStmt] { ... } +# 451| getElement(0): [YieldStmt] yield ... +# 452| getMember(4): [PatternBindingDecl] var ... = ... +# 452| getPattern(0): [TypedPattern] ... as ... +# 452| getSubPattern(): [NamedPattern] mayB +# 452| getTypeRepr(): [TypeRepr] B? +# 452| getMember(5): [ConcreteVarDecl] mayB +# 452| Type = B? +# 452| getAccessorDecl(0): [AccessorDecl] get +# 452| InterfaceType = (A) -> () -> B? +# 452| getSelfParam(): [ParamDecl] self +# 452| Type = A +# 452| getBody(): [BraceStmt] { ... } +# 452| getAccessorDecl(1): [AccessorDecl] set +# 452| InterfaceType = (inout A) -> (B?) -> () +# 452| getSelfParam(): [ParamDecl] self +# 452| Type = A +# 452| getParam(0): [ParamDecl] value +# 452| Type = B? +# 452| getBody(): [BraceStmt] { ... } +# 452| getAccessorDecl(2): [AccessorDecl] (unnamed function decl) +# 452| InterfaceType = (inout A) -> () -> () +# 452| getSelfParam(): [ParamDecl] self +# 452| Type = A +# 452| getBody(): [BraceStmt] { ... } +# 452| getElement(0): [YieldStmt] yield ... +# 449| getMember(6): [ConstructorDecl] init(b:bs:mayB:) +# 449| InterfaceType = (A.Type) -> (B, [B], B?) -> A +# 449| getSelfParam(): [ParamDecl] self +# 449| Type = A +# 449| getParam(0): [ParamDecl] b +# 449| Type = B +# 449| getParam(1): [ParamDecl] bs +# 449| Type = [B] +# 449| getParam(2): [ParamDecl] mayB +# 449| Type = B? +# 455| [ConcreteFuncDecl] test(a:) +# 455| InterfaceType = (A) -> () +# 455| getParam(0): [ParamDecl] a +# 455| Type = A +# 455| getBody(): [BraceStmt] { ... } +# 456| getElement(0): [PatternBindingDecl] var ... = ... +# 456| getInit(0): [KeyPathExpr] #keyPath(...) +# 456| getRoot(): [TypeRepr] A +# 456| getPattern(0): [NamedPattern] kpGet_b_x +# 456| getElement(1): [ConcreteVarDecl] kpGet_b_x +# 456| Type = WritableKeyPath +# 457| getElement(2): [PatternBindingDecl] var ... = ... +# 457| getInit(0): [KeyPathExpr] #keyPath(...) +# 457| getRoot(): [TypeRepr] A +# 457| getPattern(0): [NamedPattern] kpGet_bs_0_x +# 457| getElement(3): [ConcreteVarDecl] kpGet_bs_0_x +# 457| Type = WritableKeyPath +# 458| getElement(4): [PatternBindingDecl] var ... = ... +# 458| getInit(0): [KeyPathExpr] #keyPath(...) +# 458| getRoot(): [TypeRepr] A +# 458| getPattern(0): [NamedPattern] kpGet_mayB_force_x +# 458| getElement(5): [ConcreteVarDecl] kpGet_mayB_force_x +# 458| Type = WritableKeyPath +# 459| getElement(6): [PatternBindingDecl] var ... = ... +# 459| getInit(0): [KeyPathExpr] #keyPath(...) +# 459| getRoot(): [TypeRepr] A +# 459| getPattern(0): [NamedPattern] kpGet_mayB_x +# 459| getElement(7): [ConcreteVarDecl] kpGet_mayB_x +# 459| Type = KeyPath +# 461| getElement(8): [PatternBindingDecl] var ... = ... +# 461| getInit(0): [KeyPathApplicationExpr] \...[...] +# 461| getBase(): [DeclRefExpr] a +# 461| getKeyPath(): [DeclRefExpr] kpGet_b_x +# 461| getKeyPath().getFullyConverted(): [LoadExpr] (WritableKeyPath) ... +# 461| getPattern(0): [NamedPattern] apply_kpGet_b_x +# 461| getElement(9): [ConcreteVarDecl] apply_kpGet_b_x +# 461| Type = Int +# 462| getElement(10): [PatternBindingDecl] var ... = ... +# 462| getInit(0): [KeyPathApplicationExpr] \...[...] +# 462| getBase(): [DeclRefExpr] a +# 462| getKeyPath(): [DeclRefExpr] kpGet_bs_0_x +# 462| getKeyPath().getFullyConverted(): [LoadExpr] (WritableKeyPath) ... +# 462| getPattern(0): [NamedPattern] apply_kpGet_bs_0_x +# 462| getElement(11): [ConcreteVarDecl] apply_kpGet_bs_0_x +# 462| Type = Int +# 463| getElement(12): [PatternBindingDecl] var ... = ... +# 463| getInit(0): [KeyPathApplicationExpr] \...[...] +# 463| getBase(): [DeclRefExpr] a +# 463| getKeyPath(): [DeclRefExpr] kpGet_mayB_force_x +# 463| getKeyPath().getFullyConverted(): [LoadExpr] (WritableKeyPath) ... +# 463| getPattern(0): [NamedPattern] apply_kpGet_mayB_force_x +# 463| getElement(13): [ConcreteVarDecl] apply_kpGet_mayB_force_x +# 463| Type = Int +# 464| getElement(14): [PatternBindingDecl] var ... = ... +# 464| getInit(0): [KeyPathApplicationExpr] \...[...] +# 464| getBase(): [DeclRefExpr] a +# 464| getKeyPath(): [DeclRefExpr] kpGet_mayB_x +# 464| getKeyPath().getFullyConverted(): [LoadExpr] (KeyPath) ... +# 464| getPattern(0): [NamedPattern] apply_kpGet_mayB_x +# 464| getElement(15): [ConcreteVarDecl] apply_kpGet_mayB_x +# 464| Type = Int? +# 467| [ConcreteFuncDecl] testIfConfig() +# 467| InterfaceType = () -> () +# 467| getBody(): [BraceStmt] { ... } +# 468| getElement(0): [IfConfigDecl] #if ... +# 472| getElement(1): [IntegerLiteralExpr] 3 +# 473| getElement(2): [IntegerLiteralExpr] 4 +# 476| getElement(3): [IntegerLiteralExpr] 5 +# 478| getElement(4): [IfConfigDecl] #if ... +# 483| getElement(5): [IntegerLiteralExpr] 8 +# 485| getElement(6): [IfConfigDecl] #if ... +# 489| getElement(7): [IntegerLiteralExpr] 11 +# 490| getElement(8): [IntegerLiteralExpr] 12 +# 493| getElement(9): [IntegerLiteralExpr] 13 declarations.swift: # 1| [StructDecl] Foo # 2| getMember(0): [PatternBindingDecl] var ... = ... diff --git a/swift/ql/test/library-tests/ast/cfg.swift b/swift/ql/test/library-tests/ast/cfg.swift new file mode 100644 index 00000000000..38feda245de --- /dev/null +++ b/swift/ql/test/library-tests/ast/cfg.swift @@ -0,0 +1,494 @@ +var topLevelDecl : Int = 0 +0 +topLevelDecl + 1 + +func returnZero() -> Int { return 0 } + +returnZero() +Double(topLevelDecl) + +enum MyError: Error { + case error1, error2 + case error3(withParam: Int) +} + +func isZero(x : Int) -> Bool { return x == 0 } + +func mightThrow(x : Int) throws -> Void { + guard x >= 0 else { + throw MyError.error1 + } + guard x <= 0 else { + throw MyError.error3(withParam: x + 1) + } +} + +func tryCatch(x : Int) -> Int { + do { + try mightThrow(x: 0) + print("Did not throw.") + try! mightThrow(x: 0) + print("Still did not throw.") + + } catch MyError.error1 , MyError.error2 where isZero(x: x) { + return 0 + } catch MyError.error3(let withParam) { + return withParam + } catch is MyError { + print("MyError") + } catch { + print("Unknown error \(error)") + } + return 0 +} + +func createClosure1(s : String) -> () -> String { + return { + return s + "" + } +} + +func createClosure2(x : Int) -> (_ : Int) -> Int { + func f(y : Int) -> Int { + return x + y + } + return f +} + +func createClosure3(x : Int) -> (_ : Int) -> Int { + return { + (y) -> Int in x + y + } +} + +func callClosures() { + var x1 = createClosure1(s: "")() + var x2 = createClosure2(x: 0)(10) + var x3 = createClosure3(x: 0)(10) +} + +func maybeParseInt(s : String) -> Int? { + var n : Int? = Int(s) + return n +} + +func forceAndBackToOptional() -> Int? { + var nBang = maybeParseInt(s:"42")! + var n = maybeParseInt(s:"42") + return nBang + n! +} + +func testInOut() -> Int { + var temp = 10 + + func add(a: inout Int) { + a = a + 1 + } + + func addOptional(a: inout Int?) { + a = nil + } + + add(a:&temp) + var tempOptional : Int? = 10 + addOptional(a:&tempOptional) + return temp + tempOptional! +} + +class C { + let myInt: Int + init(n: Int) { + myInt = n + } + + func getMyInt() -> Int { + return myInt + } +} + +func testMemberRef(param : C, inoutParam : inout C, opt : C?) { + let c = C(n: 42) + let n1 = c.myInt + let n2 = c.self.myInt + let n3 = c.getMyInt() + let n4 = c.self.getMyInt() + + let n5 = param.myInt + let n6 = param.self.myInt + let n7 = param.getMyInt() + let n8 = param.self.getMyInt() + + let n9 = inoutParam.myInt + let n10 = inoutParam.self.myInt + let n11 = inoutParam.getMyInt() + let n12 = inoutParam.self.getMyInt() + + let n13 = opt!.myInt + let n14 = opt!.self.myInt + let n15 = opt!.getMyInt() + let n16 = opt!.self.getMyInt() + + let n17 = opt?.myInt + let n18 = opt?.self.myInt + let n19 = opt?.getMyInt() + let n20 = opt?.self.getMyInt() +} + +func patterns(x : Int) -> Bool { + for _ in 0...10 { } + + switch x { + case 0, 1: + return true + return true + case x where (x >= 2) && x < 5: + return true + default: + return false + } + + var obj : AnyObject = C(n: x) + if obj is C { + return true + } + + let xOptional: Int? = x + if case .some(let x) = xOptional { + return x == 0 + } else { + return false + } +} + +func testDefer(x : inout Int) { + // Will print 1, 2, 3, 4 + defer { + print("4") + } + + defer { + print("3") + } + + defer { + print("1") + defer { + print("2") + } + } +} + +func m1(x : Int) { + if x > 2 { + print("x is greater than 2") + } + else if x <= 2 && x > 0 && !(x == 5) { + print("x is 1") + } + else { + print("I can't guess the number") + } +} + +func m2(b : Bool) -> Int { + if b { + return 0 + } + return 1 +} + +func m3(x : inout Int) -> Int { + if x < 0 { + x = -x + if x > 10 { + x = x - 1 + } + } + return x +} + +func m4 (b1 : Bool, b2 : Bool, b3 : Bool) -> String { + return (b1 ? b2 : b3) ? "b2 || b3" : "!b2 || !b3" +} + +func conversionsInSplitEntry (b : Bool) -> String { + if b ? (true) : Bool(false) { + return "b" + } + else { + return "!b" + } +} + +func constant_condition() { + if !true { + print("Impossible") + } +} + +func empty_else(b : Bool) { + if b { + print("true") + } + else {} + print("done") +} + +func disjunct (b1 : Bool, b2 : Bool) { + if (b1 || b2) { + print("b1 or b2") + } +} + +func binaryExprs(a : Int, b : Int) { + let c = a + b + let d = a - b + let e = a * b + let f = a / b + let g = a % b + let h = a & b + let i = a | b + let j = a ^ b + let k = a << b + let l = a >> b + let o = a == b + let p = a != b + let q = a < b + let r = a <= b + let s = a > b + let t = a >= b +} + +func interpolatedString(x : Int, y : Int) -> String { + return "\(x) + \(y) is equal to \(x + y) and here is a zero: \(returnZero())" +} + +func testSubscriptExpr() -> (Int, Int, Int, Int, Int) { + var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] + a[0] = 0 + a[1] += 1 + a[2] -= 1 + a[3] *= 1 + a[4] /= 1 + a[5] %= 1 + a[6] &= 1 + a[7] |= 1 + a[8] ^= 1 + a[9] <<= 1 + a[10] >>= 1 + + var tupleWithA = (a[0], a[1], a[2], a[3], a[4]) + + var b = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] + b[0] = a[10] + b[1] = b[0] + 1 + b[2] = b[1] - 1 + b[3] = b[2] * 1 + b[4] = b[3] / 1 + b[5] = b[4] % 1 + b[6] = b[5] & 1 + b[7] = b[6] | 1 + b[8] = b[7] ^ 1 + b[9] = b[8] << 1 + b[10] = b[9] >> 1 + + let (a1, a2, a3, a4, a5) = tupleWithA + return (a1 + b[0], a2 + b[1], a3 + b[2], a4 + b[3], a5 + b[4]) +} + +func loop1(x : inout Int) { + while x >= 0 { + print(x) + x -= 1 + } +} + +func loop2(x : inout Int) { + while x >= 0 { + print(x) + x -= 1 + if x > 100 { + break + } + else if x > 50 { + continue + } + print("Iter") + } + print("Done") +} + +func labeledLoop(x : inout Int) { + outer: while x >= 0 { + inner: while x >= 0 { + print(x) + x -= 1 + if x > 100 { + break outer + } + else if x > 50 { + continue inner + } + print("Iter") + } + print("Done") + } +} + +func testRepeat(x : inout Int) { + repeat { + print(x) + x -= 1 + } while x >= 0 +} + +func loop_with_identity_expr() { + var x = 0 + while(x < 10) { + x += 1 + } +} + +class OptionalC { + let c: C? + init(arg: C?) { + c = arg + } + + func getOptional() -> C? { + return c + } +} + +func testOptional(c : OptionalC?) -> Int? { + return c?.getOptional()?.getMyInt() +} + +func testCapture(x : Int, y : Int) -> () -> Int { + return { [z = x + y, t = "literal"] in + return z + } +} + +func testTupleElement(t : (a: Int, Int, c: Int)) -> Int { + return t.a + t.1 + t.c + (1, 2, 3).0 +} + +class Derived : C { + init() { + super.init(n: 0) + } +} + +func doWithoutCatch(x : Int) throws -> Int { + do { + try mightThrow(x: 0) + print("Did not throw.") + try! mightThrow(x: 0) + print("Still did not throw.") + } + return 0 +} + +class Structors { + var field: Int + init() { + field = 10 + } + + deinit { + field = 0 + } +} + +func dictionaryLiteral(x: Int, y: Int) -> [String: Int] { + return ["x": x, "y": y] +} + +func localDeclarations() -> Int { + class MyLocalClass { + var x: Int + init() { + x = 10 + } + } + + struct MyLocalStruct { + var x: Int + init() { + x = 10 + } + } + + enum MyLocalEnum { + case A + case B + } + + var myLocalVar : Int; + + // Error: declaration is only valid at file scope + // extension Int { + // func myExtensionMethod() -> Int { + // return self + // } + // } + + // protocol 'MyProtocol' cannot be nested inside another declaration + // protocol MyProtocol { + // func myMethod() + // } + + return 0 +} + +struct B { + var x : Int +} + +struct A { + var b : B + var bs : [B] + var mayB : B? +} + +func test(a : A) { + var kpGet_b_x = \A.b.x + var kpGet_bs_0_x = \A.bs[0].x + var kpGet_mayB_force_x = \A.mayB!.x + var kpGet_mayB_x = \A.mayB?.x + + var apply_kpGet_b_x = a[keyPath: kpGet_b_x] + var apply_kpGet_bs_0_x = a[keyPath: kpGet_bs_0_x] + var apply_kpGet_mayB_force_x = a[keyPath: kpGet_mayB_force_x] + var apply_kpGet_mayB_x = a[keyPath: kpGet_mayB_x] +} + +func testIfConfig() { +#if FOO + 1 + 2 +#else + 3 + 4 +#endif + + 5 + +#if BAR + 6 + 7 +#endif + + 8 + +#if FOO + 9 + 10 +#elseif true + 11 + 12 +#endif + + 13 +}