仓颉文档阅读-语言规约XVIII: 仓颉语法

NOTE
阅读文档版本:
语言规约 Cangjie-0.53.18-Spec
具体开发指南 Cangjie-LTS-1.0.3
在阅读了解仓颉的语言规约时, 难免会涉及到一些仓颉的示例代码, 但我们对仓颉并不熟悉, 所以可以用仓颉在线体验快速验证
有条件当然可以直接配置Canjie-SDK

WARNING
博主在此之前, 基本只接触过C/C++语言, 对大多现代语言都没有了解, 所以在阅读过程中遇到相似的概念, 难免会与C/C++中的相似概念作类比, 见谅

此样式内容, 表示文档原文内容

仓颉语法#

本文的内容, 都是仓颉语法的词法规则, 与语言特性无关

词法#

注释#

1
DelimitedComment
2
    : '/*' ( DelimitedComment | . )*? '*/'
3
    ;
4

5
LineComment
6
    : '//' ~[\u000A\u000D]*
7
    ;

1
/* 多行注释 */
2

3
// 单行注释

空白和换行#

1
WS
2
    : [\u0020\u0009\u000C]
3
    ;
4

5
NL: '\u000A' | '\u000D' '\u000A' ;

1
// 空格(\u0020)
2

3
// 制表符(\u0009)
4

5
// 换页符(\u000C)
6

7

8
// Uinx/Linux风格换行 LF(\u000A)
9

10
// Windows风格换行 CRLF(\u000D \u000A)

符号#

1
DOT: '.' ;
2
COMMA: ',' ;
3
LPAREN: '(' ;
4
RPAREN: ')' ;
5
LSQUARE: '[' ;
6
RSQUARE: ']' ;
7
LCURL: '{' ;
8
RCURL: '}' ;
9
EXP: '**' ;
10
MUL: '*' ;
11
MOD: '%' ;
12
DIV: '/' ;
13
ADD: '+' ;
14
SUB: '-' ;
15
PIPELINE: '|>' ;
16
COMPOSITION: '~>' ;
17
INC: '++' ;
18
DEC: '--' ;
19
AND: '&&' ;
20
OR: '||' ;
21
NOT: '!' ;
22
BITAND: '&' ;
23
BITOR: '|' ;
24
BITXOR: '^' ;
25
LSHIFT: '<<' ;
26
RSHIFT: '>>' ;
27
COLON: ':' ;
28
SEMI: ';' ;
29
ASSIGN: '=' ;
30
ADD_ASSIGN: '+=' ;
31
SUB_ASSIGN: '-=' ;
32
MUL_ASSIGN: '*=' ;
33
EXP_ASSIGN: '**=' ;
34
DIV_ASSIGN: '/=' ;
35
MOD_ASSIGN: '%=' ;
36
AND_ASSIGN: '&&=' ;
37
OR_ASSIGN: '||=' ;
38
BITAND_ASSIGN: '&=' ;
39
BITOR_ASSIGN: '|=' ;
40
BITXOR_ASSIGN: '^=' ;
41
LSHIFT_ASSIGN: '<<=' ;
42
RSHIFT_ASSIGN: '>>=' ;
43
ARROW: '->' ;
44
BACKARROW: '<-' ;
45
DOUBLE_ARROW: '=>' ;
46
ELLIPSIS: '...' ;
47
CLOSEDRANGEOP: '..=' ;
48
RANGEOP: '..' ;
49
HASH: '#' ;
50
AT: '@' ;
51
QUEST: '?' ;
52
UPPERBOUND: '<:';
53
LT: '<' ;
54
GT: '>' ;
55
LE: '<=' ;
56
GE: '>=' ;
57
NOTEQUAL: '!=' ;
58
EQUAL: '==' ;
59
WILDCARD: '_' ;
60
BACKSLASH: '\\' ;
61
QUOTESYMBOL: '`';
62
DOLLAR: '$';
63
QUOTE_OPEN: '"' ;
64
TRIPLE_QUOTE_OPEN: '"""' NL;
65
QUOTE_CLOSE: '"' ;
66
TRIPLE_QUOTE_CLOSE: '"""' ;
67
LineStrExprStart: '${' ;
68
MultiLineStrExprStart: '${' ;

关键字#

1
INT8: 'Int8' ;
2
INT16: 'Int16' ;
3
INT32: 'Int32' ;
4
INT64: 'Int64' ;
5
INTNATIVE: 'IntNative' ;
6
UINT8: 'UInt8' ;
7
UINT16: 'UInt16' ;
8
UINT32: 'UInt32' ;
9
UINT64: 'UInt64' ;
10
UINTNATIVE: 'UIntNative' ;
11
FLOAT16: 'Float16' ;
12
FLOAT32: 'Float32' ;
13
FLOAT64: 'Float64' ;
14
RUNE: 'Rune' ;
15
BOOLEAN: 'Bool' ;
16
UNIT: 'Unit' ;
17
Nothing: 'Nothing' ;
18
STRUCT: 'struct' ;
19
ENUM: 'enum' ;
20
THISTYPE: 'This';
21
PACKAGE: 'package' ;
22
IMPORT: 'import' ;
23
CLASS: 'class' ;
24
INTERFACE: 'interface' ;
25
FUNC: 'func';
26
MAIN: 'main';
27
LET: 'let' ;
28
VAR: 'var' ;
29
CONST: 'const' ;
30
TYPE_ALIAS: 'type' ;
31
INIT: 'init'  ;
32
THIS: 'this' ;
33
SUPER: 'super' ;
34
IF: 'if' ;
35
ELSE: 'else' ;
36
CASE: 'case' ;
37
TRY: 'try' ;
38
CATCH: 'catch' ;
39
FINALLY: 'finally' ;
40
FOR: 'for' ;
41
DO: 'do' ;
42
WHILE: 'while' ;
43
THROW: 'throw' ;
44
RETURN: 'return' ;
45
CONTINUE: 'continue' ;
46
BREAK: 'break' ;
47
IS: 'is' ;
48
AS: 'as' ;
49
IN: 'in' ;
50
MATCH: 'match' ;
51
FROM: 'from' ;
52
WHERE: 'where';
53
EXTEND: 'extend';
54
SPAWN: 'spawn';
55
SYNCHRONIZED: 'synchronized';
56
MACRO: 'macro';
57
QUOTE: 'quote';
58
TRUE: 'true';
59
FALSE: 'false';
60
STATIC: 'static';
61
PUBLIC: 'public' ;
62
PRIVATE: 'private' ;
63
PROTECTED: 'protected' ;
64
OVERRIDE: 'override' ;
65
REDEF: 'redef' ;
66
ABSTRACT: 'abstract' ;
67
OPEN: 'open' ;
68
OPERATOR: 'operator' ;
69
FOREIGN: 'foreign';
70
INOUT: 'inout';
71
PROP: 'prop';
72
MUT: 'mut';
73
UNSAFE: 'unsafe';
74
GET: 'get';
75
SET: 'set';

字面量#

1
IntegerLiteralSuffix
2
   : 'i8' |'i16' |'i32' |'i64' |'u8' |'u16' |'u32' | 'u64'
3
   ;
4

5
IntegerLiteral
6
   : BinaryLiteral IntegerLiteralSuffix?
7
   | OctalLiteral IntegerLiteralSuffix?
8
   | DecimalLiteral '_'* IntegerLiteralSuffix?
9
   | HexadecimalLiteral IntegerLiteralSuffix?
10
   ;
11
BinaryLiteral
12
    : '0' [bB] BinDigit (BinDigit | '_')*
13
    ;
14
BinDigit
15
    : [01]
16
    ;
17
OctalLiteral
18
    : '0' [oO] OctalDigit (OctalDigit | '_')*
19
    ;
20
OctalDigit
21
    : [0-7]
22
    ;
23
DecimalLiteral
24
    : (DecimalDigitWithOutZero (DecimalDigit | '_')*) | DecimalDigit
25
    ;
26
fragment DecimalFragment
27
    : DecimalDigit (DecimalDigit | '_')*
28
    ;
29
fragment DecimalDigit
30
    : [0-9]
31
    ;
32
fragment DecimalDigitWithOutZero
33
    : [1-9]
34
    ;
35
HexadecimalLiteral
36
    : '0' [xX] HexadecimalDigits
37
    ;
38

39
HexadecimalDigits
40
    : HexadecimalDigit (HexadecimalDigit | '_')*
41
    ;
42

43
HexadecimalDigit
44
    : [0-9a-fA-F]
45
    ;
46

47
FloatLiteralSuffix
48
    : 'f16' | 'f32' | 'f64'
49
    ;
50

51
FloatLiteral
52
    : (DecimalLiteral DecimalExponent | DecimalFraction DecimalExponent? | (DecimalLiteral DecimalFraction) DecimalExponent?)  FloatLiteralSuffix?
53
    | ( Hexadecimalprefix (HexadecimalDigits | HexadecimalFraction | (HexadecimalDigits HexadecimalFraction)) HexadecimalExponent)
54
    ;
55

56
fragment DecimalFraction : '.' DecimalFragment ;
57
fragment DecimalExponent : FloatE Sign? DecimalFragment  ;
58
fragment Sign : [-] ;
59
fragment Hexadecimalprefix : '0' [xX] ;
60

61

62
DecimalFraction : '.' DecimalLiteral ;
63
DecimalExponent : FloatE Sign? DecimalLiteral  ;
64
HexadecimalFraction : '.' HexadecimalDigits ;
65
HexadecimalExponent : FloatP Sign? DecimalFragment ;
66
FloatE : [eE] ;
67
FloatP : [pP] ;
68
Sign : [-] ;
69
Hexadecimalprefix : '0' [xX] ;
70

71
RuneLiteral
72
    : '\'' (SingleChar | EscapeSeq ) '\''
73
    ;
74

75
SingleChar
76
    :  ~['\\\r\n]
77
    ;
78

79
EscapeSeq
80
    : UniCharacterLiteral
81
    | EscapedIdentifier
82
    ;
83

84
UniCharacterLiteral
85
    : '\\' 'u' '{' HexadecimalDigit '}'
86
    | '\\' 'u' '{' HexadecimalDigit HexadecimalDigit '}'
87
    | '\\' 'u' '{' HexadecimalDigit HexadecimalDigit HexadecimalDigit '}'
88
    | '\\' 'u' '{' HexadecimalDigit HexadecimalDigit HexadecimalDigit HexadecimalDigit '}'
89
    | '\\' 'u' '{' HexadecimalDigit HexadecimalDigit HexadecimalDigit HexadecimalDigit HexadecimalDigit '}'
90
    | '\\' 'u' '{' HexadecimalDigit HexadecimalDigit HexadecimalDigit HexadecimalDigit HexadecimalDigit HexadecimalDigit '}'
91
    | '\\' 'u' '{' HexadecimalDigit HexadecimalDigit HexadecimalDigit HexadecimalDigit HexadecimalDigit HexadecimalDigit HexadecimalDigit '}'
92
    | '\\' 'u' '{' HexadecimalDigit HexadecimalDigit HexadecimalDigit HexadecimalDigit HexadecimalDigit HexadecimalDigit HexadecimalDigit HexadecimalDigit '}'
93
    ;
94

95
EscapedIdentifier
96
    : '\\' ('t' | 'b' | 'r' | 'n' | '\'' | '"' | '\\' | 'f' | 'v' | '0' | '$')
97
    ;
98

99
ByteLiteral
100
    : 'b' '\'' (SingleCharByte | ByteEscapeSeq) '\''
101
    ;
102

103
ByteEscapeSeq
104
    : HexCharByte
105
    | ByteEscapedIdentifier
106
    ;
107

108
SingleCharByte
109
    // ASCII 0x00~0x7F without \n \r \' \" \\
110
    // +-------+-----+-----+
111
    // | Rune  | Hex | Dec |
112
    // +-------+-----+-----+
113
    // | \n    |  0A |  10 |
114
    // | \r    |  0D |  13 |
115
    // | \"    |  22 |  34 |
116
    // | \'    |  27 |  39 |
117
    // | \\    |  5C |  92 |
118
    // +-------+-----+-----+
119
    : [\u0000-\u0009\u000B\u000C\u000E-\u0021\u0023-\u0026\u0028-\u005B\u005D-\u007F]
120
    ;
121

122
fragment ByteEscapedIdentifier
123
    : '\\' ('t' | 'b' | 'r' | 'n' | '\'' | '"' | '\\' | 'f' | 'v' | '0')
124
    ;
125

126
fragment HexCharByte
127
    : '\\' 'u' '{' HexadecimalDigit '}'
128
    | '\\' 'u' '{' HexadecimalDigit HexadecimalDigit '}'
129
    ;
130

131
ByteStringArrayLiteral
132
    : 'b' '"' (SingleCharByte | ByteEscapeSeq)* '"'
133
    ;
134

135
JStringLiteral
136
    : 'J' '"' (SingleChar | EscapeSeq)* '"'
137
    ;
138

139
LineStrText
140
    : ~["\\\r\n]
141
    | EscapeSeq
142
    ;
143

144
TRIPLE_QUOTE_CLOSE
145
    : MultiLineStringQuote? '"""' ;
146

147
MultiLineStringQuote
148
    : '"'+
149
    ;
150

151
MultiLineStrText
152
    : ~('\\')
153
    | EscapeSeq
154
    ;
155

156
MultiLineRawStringLiteral
157
    : MultiLineRawStringContent
158
    ;
159

160
fragment MultiLineRawStringContent
161
    : HASH MultiLineRawStringContent HASH
162
    | HASH '"' .*? '"' HASH
163
    ;

1
// 整型字面量
2
// 二进制整型
3
0b1010
4
0B1010
5
// 八进制整型
6
0o755
7
0O755
8
// 十进制整型
9
42
10
1_000_000
11
// 十六进制整型
12
0xFF
13
0XFF
14
// 可加后缀
15
i8 | i16 | i32 | i64
16
u8 | u16 | u32 | u64
17

18

19
// 浮点数字面量
20
// 十进制浮点
21
3.14
22
6.02e23
23
1e-10f64
24
// 十六进制浮点
25
0x1.FFFFp0
26
0x1p-10
27
// 可加后缀
28
f16 | f32 | f64
29

30

31
// 字符字面量
32
// 普通字符
33
'A'
34
// 转义字符:
35
'\n'
36
'\u{1F600}'
37
'\''
38

39

40
// 字节字面量
41
// ASCII字符
42
b'x'
43
// 十六进制值
44
b'\u{78}'
45
// 转义序列
46
b'\n'
47

48
// 字节字符串字面量
49
b"Hello\x00World"
50

51

52
// J字符串字面量
53
J"包含\n换行的字符串"
54

55

56
// 单行字符串字面量
57
"包含\"引号\"的字符串"
58
'包含\'引号\'的字符串'
59

60

61
// 多行字符串字面量
62
"""
63
春眠不觉晓，
64
处处闻啼鸟。
65
"""
66

67

68
// 多行原始字符串字面量
69
#"
70
This is a \raw string
71
\n will NOT be escaped
72
"#
73

74

75
// 插值字符串
76
"你好, ${name}"

等

标识符#

1
identifier
2
    : Identifier
3
    | PUBLIC
4
    | PRIVATE
5
    | PROTECTED
6
    | OVERRIDE
7
    | ABSTRACT
8
    | OPEN
9
    | REDEF
10
    | GET
11
    | SET
12
    ;
13

14
Identifier
15
    : '_'* Letter (Letter | '_' | DecimalDigit)*
16
    | '`' '_'* Letter (Letter | '_' | DecimalDigit)* '`'
17
    ;
18

19
Letter
20
    : [a-zA-Z]
21
    ;
22

23
DollarIdentifier
24
    : '$' Identifier
25
    ;

1
// 普通标识符
2
age, _count, MAX_1
3

4
// 原始标识符
5
`class`, `_`
6
`public`
7

8
// $标识符
9
$temp, $_

语法#

编译单元#

1
translationUnit
2
    : NL* preamble end* topLevelObject* (end+ mainDefinition)? NL* (topLevelObject (end+ topLevelObject?)*)? EOF
3
    ;
4

5
end
6
    : NL | SEMI
7
    ;

1
// 最小文件
2
main() {}
3

4
// 完整结构
5
package com.example
6
import std.io.*
7

8
let x = 42
9

10
public class A {}
11

12
main() {
13
    println(x)
14
}
15

16
func helper() {}

包定义和包导入#

1
preamble
2
    : packageHeader? importList*
3
    ;
4

5
packageHeader
6
    : PACKAGE NL* packageNameIdentifier end+
7
    ;
8

9
packageNameIdentifier
10
    : identifier (NL* DOT NL* identifier)*
11
    ;
12

13
importList
14
    : (FROM NL* identifier)? NL* IMPORT NL* importAllOrSpecified
15
    (NL* COMMA NL* importAllOrSpecified)* end+
16
    ;
17

18
importAllOrSpecified
19
    : importAll
20
    | importSpecified (NL* importAlias)?
21
    ;
22

23
importSpecified
24
    : (identifier NL* DOT NL*)+ identifier
25
    ;
26

27
importAll
28
    : (identifier NL* DOT NL*)+ MUL
29
    ;
30

31
importAlias
32
    : AS NL* identifier
33
    ;

1
// 包的定义
2
package com.example         // 包声明后需换行或分号
3
package com.example.utils;  // 分号结尾
4

5
// 包的导入
6
package com.example
7

8
// 基础
9
import std.io.*
10
import com.utils.{Timer, Logger}
11
import net.Http as NetHttp
12

13
// 多行
14
import std.collections.{
15
    HashMap,
16
    HashSet as HS
17
}  // 多行导入需用逗号分隔

`top-level` 定义#

1
topLevelObject
2
    : classDefinition
3
    | interfaceDefinition
4
    | functionDefinition
5
    | variableDeclaration
6
    | enumDefinition
7
    | structDefinition
8
    | typeAlias
9
    | extendDefinition
10
    | foreignDeclaration
11
    | macroDefinition
12
    | macroExpression
13
    ;

1
// classDefinition
2
public class Rectangle {}
3
// interfaceDefinition
4
interface Drawable {}
5
// functionDefinition
6
func max(a: Int64, b: Int64): Int64 {}
7
// variableDeclaration
8
let PI: Float64 = 3.1415926
9
var counter: Int64 = 0
10
// enumDefinition
11
public enum Color {
12
    RED, GREEN, BLUE
13
}
14
// structDefinition
15
struct Point {}
16
// typeAlias
17
type UserID = String
18
type Callback = (Int64) -> Unit
19
// extendDefinition
20
extend Int64 {}
21
// foreignDeclaration
22
foreign func foo(): Unit
23
// macroDefinition
24
public macro foo(x: Tokens): Tokens { x }
25
// macroExpression
26
@Twice(foo())

`class` 定义#

1
classDefinition
2
    : (classModifierList NL*)? CLASS NL* identifier
3
    (NL* typeParameters NL*)?
4
    (NL* UPPERBOUND NL* superClassOrInterfaces)?
5
    (NL* genericConstraints)?
6
    NL* classBody
7
    ;
8

9
superClassOrInterfaces
10
    : superClass (NL* BITAND NL* superInterfaces)?
11
    | superInterfaces
12
    ;
13

14
classModifierList
15
    : classModifier+
16
    ;
17

18
classModifier
19
    : PUBLIC
20
    | PROTECTED
21
    | INTERNAL
22
    | PRIVATE
23
    | ABSTRACT
24
    | OPEN
25
    ;
26

27
typeParameters
28
    : LT NL* identifier (NL* COMMA NL* identifier)* NL* GT
29
    ;
30

31
superClass
32
    : classType
33
    ;
34

35
classType
36
    : (identifier NL* DOT  NL*)*  identifier (NL* typeParameters)?
37
    ;
38

39
typeArguments
40
    : LT NL* type (NL* COMMA NL* type)* NL* GT
41
    ;
42

43
superInterfaces
44
    : interfaceType (NL* COMMA NL* interfaceType )*
45
    ;
46

47
interfaceType
48
    : classType
49
    ;
50

51
genericConstraints
52
    : WHERE NL* (identifier | THISTYPE) NL* UPPERBOUND NL* upperBounds (NL* COMMA NL* (identifier | THISTYPE) NL* UPPERBOUND NL* upperBounds)*
53
    ;
54

55
upperBounds
56
    : type (NL* BITAND NL* type)*
57
    ;
58

59
classBody
60
    : LCURL end*
61
         classMemberDeclaration* NL*
62
         classPrimaryInit? NL*
63
         classMemberDeclaration* end* RCURL
64
    ;
65

66
classMemberDeclaration
67
    : (classInit
68
    | staticInit
69
    | variableDeclaration
70
    | functionDefinition
71
    | operatorFunctionDefinition
72
    | macroExpression
73
    | propertyDefinition
74
    ) end*
75
    ;
76

77
classInit
78
    : (classNonStaticMemberModifier | CONST NL*)? INIT NL* functionParameters NL* block
79
    ;
80

81
staticInit
82
    : STATIC INIT LPAREN RPAREN
83
    LCURL
84
    expressionOrDeclarations?
85
    RCURL
86
    ;
87

88
classPrimaryInit
89
    : (classNonStaticMemberModifier | CONST NL*)?  className NL* LPAREN NL*
90
          classPrimaryInitParamLists
91
       NL* RPAREN NL*
92
     LCURL NL*
93
          (SUPER callSuffix)? end
94
          expressionOrDeclarations?
95
     NL* RCURL
96
    ;
97

98
className
99
    : identifier
100
    ;
101

102
classPrimaryInitParamLists
103
    : unnamedParameterList (NL* COMMA NL* namedParameterList)? (NL* COMMA NL* classNamedInitParamList)?
104
    | unnamedParameterList (NL* COMMA NL* classUnnamedInitParamList)? (NL* COMMA NL* classNamedInitParamList)?
105
    | classUnnamedInitParamList (NL* COMMA NL* classNamedInitParamList)?
106
    | namedParameterList (NL* COMMA NL* classNamedInitParamList)?
107
    | classNamedInitParamList
108
    ;
109

110
classUnnamedInitParamList
111
    : classUnnamedInitParam (NL* COMMA NL* classUnnamedInitParam)*
112
    ;
113

114
classNamedInitParamList
115
    : classNamedInitParam (NL* COMMA NL* classNamedInitParam)*
116
    ;
117

118
classUnnamedInitParam
119
    : (classNonSMemberModifier NL*)? (LET | VAR) NL* identifier NL* COLON NL* type
120
    ;
121

122
classNamedInitParam
123
    : (classNonSMemberModifier NL*)? (LET | VAR) NL* identifier NL* NOT NL* COLON NL* type (NL* ASSIGN NL* expression)?
124
    ;
125

126
classNonStaticMemberModifier
127
    : PUBLIC
128
    | PRIVATE
129
    | PROTECTED
130
    | INTERNAL
131
    ;

1
public class SimpleClass <: BaseClass & IInterface {
2
    // 成员变量
3
    var value: Int64 = 10
4
    let name: String
5

6
    // 主构造函数
7
    SimpleClass(value: Int64, name!: String) {
8
        this.value = value
9
        this.name = name
10
    }
11

12
    init(name!: String) {
13
        this.name = name
14
    }
15

16
    // 方法
17
    public func printInfo(): Unit {
18
        println("${name}: ${value}")
19
    }
20

21
    // 实现接口
22
    public func print(): Unit {
23
        println("name: ${this.name}, value: ${this.value}")
24
    }
25
}

`interface` 定义#

1
interfaceDefinition
2
    : (interfaceModifierList NL*)? INTERFACE NL* identifier
3
    (NL* typeParameters NL*)?
4
    (NL* UPPERBOUND NL* superInterfaces)?
5
    (NL* genericConstraints)?
6
    (NL* interfaceBody)
7
    ;
8

9
interfaceBody
10
    : LCURL end* interfaceMemberDeclaration* end* RCURL
11
    ;
12

13
interfaceMemberDeclaration
14
    : (functionDefinition
15
    | operatorFunctionDefinition
16
    | macroExpression
17
    | propertyDefinition) end*
18
    ;
19

20
interfaceModifierList
21
    : (interfaceModifier NL*)+
22
    ;
23

24
interfaceModifier
25
    : PUBLIC
26
    | PROTECTED
27
    | INTERNAL
28
    | PRIVATE
29
    | OPEN
30
    ;

1
internal interface SimpleInterface {
2
    // 抽象方法(无实现)
3
    func doSomething(): Unit
4

5
    // 带默认实现的方法
6
    func log(message: String) {
7
        println(message)
8
    }
9

10
    // 属性(只有getter)
11
    prop count: Int64
12
}

`function` 定义#

1
functionDefinition
2
    :(functionModifierList NL*)? FUNC
3
    NL* identifier
4
    (NL* typeParameters NL*)?
5
    NL* functionParameters
6
    (NL* COLON NL* type)?
7
    (NL* genericConstraints)?
8
    (NL* block)?
9
    ;
10

11
operatorFunctionDefinition
12
    : (functionModifierList NL*)? OPERATOR NL* FUNC
13
    NL* overloadedOperators
14
    (NL* typeParameters NL*)?
15
    NL* functionParameters
16
    (NL* COLON NL* type)?
17
    (NL* genericConstraints)?
18
    (NL* block)?
19
    ;
20

21
functionParameters
22
    : (LPAREN (NL* unnamedParameterList ( NL* COMMA NL* namedParameterList)? )?
23
        NL* RPAREN NL*)
24
    | (LPAREN NL* (namedParameterList NL*)? RPAREN NL*)
25
    ;
26

27
nondefaultParameterList
28
    : unnamedParameter (NL* COMMA NL* unnamedParameter)*
29
        (NL* COMMA NL*  namedParameter)*
30
    | namedParameter (NL* COMMA NL* namedParameter)*
31
    ;
32

33
unnamedParameterList
34
    : unnamedParameter (NL* COMMA NL*  unnamedParameter)*
35
    ;
36

37
unnamedParameter
38
    : (identifier | WILDCARD) NL* COLON NL* type
39
    ;
40

41
namedParameterList
42
    : (namedParameter | defaultParameter)
43
      (NL* COMMA NL* (namedParameter | defaultParameter))*
44
    ;
45

46
namedParameter
47
    : identifier NL* NOT NL* COLON NL* type
48
    ;
49

50
defaultParameter
51
    : identifier NL* NOT NL* COLON NL* type NL* ASSIGN NL* expression
52
    ;
53

54
functionModifierList
55
    : (functionModifier NL*)+
56
    ;
57

58
functionModifier
59
    : PUBLIC
60
    | PRIVATE
61
    | PROTECTED
62
    | INTERNAL
63
    | STATIC
64
    | OPEN
65
    | OVERRIDE
66
    | OPERATOR
67
    | REDEF
68
    | MUT
69
    | UNSAFE
70
    | CONST
71
    ;

1
// 函数
2
public func sum( a: Int64, b!: Int64 = 0): Int64 {
3
    a + b
4
}
5

6
// lambda
7
let f1: (Int64, Int64)->Int64 = {a: Int64, b: Int64 => a + b}

变量定义#

1
variableDeclaration
2
    : variableModifier* NL* (LET | VAR | CONST) NL* patternsMaybeIrrefutable ( (NL* COLON NL* type)? (NL* ASSIGN NL* expression)
3
                                                                     | (NL* COLON NL* type)
4
                                                                     )
5
    ;
6

7
variableModifier
8
    : PUBLIC
9
    | PRIVATE
10
    | PROTECTED
11
    | INTERNAL
12
    | STATIC
13
    ;

1
var varVal: Int64 = 20
2
let letVal = 20
3
const constVal = 20
4
static const sConstVal = 20  // static 不能在 top-level、main()

`enum` 定义#

1
enumDefinition
2
    : (enumModifier NL*)? ENUM NL* identifier (NL* typeParameters NL*)?
3
    (NL* UPPERBOUND NL* superInterfaces)?
4
    (NL* genericConstraints)? NL* LCURL end* enumBody end* RCURL
5
    ;
6

7
enumBody
8
    : (BITOR NL*)? caseBody (NL* BITOR NL* caseBody)*
9
    (NL*
10
    ( functionDefinition
11
    | operatorFunctionDefinition
12
    | propertyDefinition
13
    | macroExpression
14
    ))*
15
    ;
16

17
caseBody
18
    : identifier ( NL* LPAREN NL* type (NL* COMMA NL* type)* NL* RPAREN)?
19
    ;
20

21
enumModifier
22
    : PUBLIC
23
    | PROTECTED
24
    | INTERNAL
25
    | PRIVATE
26
    ;

1
internal enum StatusCode {
2
    | OK(Int64)
3
    | NotFound(Int64)
4
    | ServerError(Int64)
5

6
    // 成员方法
7
    public func isSuccess(): Bool {
8
        match (this) {
9
            case OK(_) => true
10
            case _ => false
11
        }
12
    }
13
}

`struct` 定义#

1
structDefinition
2
    : (structModifier NL*)? STRUCT NL* identifier (NL* typeParameters NL*)?
3
    (NL* UPPERBOUND NL* superInterfaces)?
4
    (NL* genericConstraints)? NL* structBody
5
    ;
6

7
structBody
8
    : LCURL end*
9
        structMemberDeclaration* NL*
10
        structPrimaryInit? NL*
11
        structMemberDeclaration*
12
      end* RCURL
13
    ;
14

15
structMemberDeclaration
16
    : (structInit
17
    | staticInit
18
    | variableDeclaration
19
    | functionDefinition
20
    | operatorFunctionDefinition
21
    | macroExpression
22
    | propertyDefinition
23
    ) end*
24
    ;
25

26
structInit
27
    : (structNonStaticMemberModifier | CONST NL*)? INIT NL* functionParameters NL* block
28
    ;
29

30
staticInit
31
    : STATIC INIT LPAREN RPAREN
32
    LCURL
33
    expressionOrDeclarations?
34
    RCURL
35
    ;
36

37
structPrimaryInit
38
    : (structNonStaticMemberModifier | CONST NL*)? structName NL* LPAREN NL* structPrimaryInitParamLists? NL* RPAREN NL*
39
     LCURL NL*
40
          expressionOrDeclarations?
41
     NL* RCURL
42
    ;
43

44
structName
45
    : identifier
46
    ;
47

48
structPrimaryInitParamLists
49
    : unnamedParameterList (NL* COMMA NL* namedParameterList)? (NL* COMMA NL* structNamedInitParamList)?
50
    | unnamedParameterList (NL* COMMA NL* structUnnamedInitParamList)? (NL* COMMA NL* structNamedInitParamList)?
51
    | structUnnamedInitParamList (NL* COMMA NL* structNamedInitParamList)?
52
    | namedParameterList (NL* COMMA NL* structNamedInitParamList)?
53
    | structNamedInitParamList
54
    ;
55

56
structUnnamedInitParamList
57
    : structUnnamedInitParam (NL* COMMA NL* structUnnamedInitParam)*
58
    ;
59

60
structNamedInitParamList
61
    : structNamedInitParam (NL* COMMA NL*  structNamedInitParam)*
62
    ;
63

64
structUnnamedInitParam
65
    : (structNonStaticMemberModifier NL*)? (LET | VAR) NL* identifier NL* COLON NL* type
66
    ;
67

68
structNamedInitParam
69
    : (structNonStaticMemberModifier NL*)? (LET | VAR) NL* identifier NL* NOT NL* COLON NL* type (NL* ASSIGN NL* expression)?
70
    ;
71

72
structModifier
73
    : PUBLIC
74
    | PROTECTED
75
    | INTERNAL
76
    | PRIVATE
77
    ;
78

79
structNonStaticMemberModifier
80
    : PUBLIC
81
    | PROTECTED
82
    | INTERNAL
83
    | PRIVATE
84
    ;

1
internal struct Point {
2
    // 成员变量
3
    var y: Int64
4

5
    // 主构造函数(简化成员变量初始化)
6
    public Point(y: Int64, var x: Int64) {
7
        this.x = x
8
        this.y = y
9
    }
10

11
    // 次构造函数
12
    public init(y: Int64) {
13
        this.x = 0
14
        this.y = y
15
    }
16

17
    // 静态初始化块
18
    static init() {
19
        println("Point initialized")
20
    }
21

22
    // 成员方法
23
    public mut func move(dx: Int64, dy!: Int64): Unit {
24
        this.y = y + dy
25
    }
26
}

类型别名定义#

1
typeAlias
2
    : (typeModifier NL*)? TYPE_ALIAS NL* identifier (NL* typeParameters)? NL* ASSIGN NL* type end*
3
    ;
4

5
typeModifier
6
    : PUBLIC
7
    | PROTECTED
8
    | INTERNAL
9
    | PRIVATE
10
    ;

1
internal type UserID = String

扩展定义#

1
extendDefinition
2
    : EXTEND NL* extendType
3
    (NL* UPPERBOUND NL* superInterfaces)? (NL* genericConstraints)?
4
    NL* extendBody
5
    ;
6

7
extendType
8
    : (typeParameters)? (identifier NL* DOT  NL*)* identifier (NL* typeArguments)?
9
    | INT8
10
    | INT16
11
    | INT32
12
    | INT64
13
    | INTNATIVE
14
    | UINT8
15
    | UINT16
16
    | UINT32
17
    | UINT64
18
    | UINTNATIVE
19
    | FLOAT16
20
    | FLOAT32
21
    | FLOAT64
22
    | RUNE
23
    | BOOLEAN
24
    | NOTHING
25
    | UNIT
26
    ;
27

28
extendBody
29
    : LCURL end* extendMemberDeclaration* end* RCURL
30
    ;
31

32
extendMemberDeclaration
33
    : (functionDefinition
34
    | operatorFunctionDefinition
35
    | macroExpression
36
    | propertyDefinition
37
    ) end*
38
    ;

1
// 直接扩展
2
extend String {
3
    func printSize() {
4
        print(this.size)
5
    }
6
}
7

8
// 接口扩展
9
interface I1 {
10
    func f1(): Unit
11
}
12

13
interface I2 {
14
    func f2(): Unit
15
}
16

17
class Foo {}
18

19
extend Foo <: I1 & I2 {
20
    public func f1() {}
21
    public func f2() {}
22
}

`foreign` 声明#

1
foreignDeclaration
2
    : FOREIGN NL* (foreignBody | foreignMemberDeclaration)
3
    ;
4

5
foreignBody
6
    : LCURL end* foreignMemberDeclaration* end* RCURL
7
    ;
8

9
foreignMemberDeclaration
10
    : (classDefinition
11
    | interfaceDefinition
12
    | functionDefinition
13
    | macroExpression
14
    | variableDeclaration) end*
15
    ;

1
foreign func printf(format: CString, ...): Int32
2

3
foreign var errno: Int32
4

5
foreign {
6
    func malloc(size: UIntNative): CPointer<Unit>
7
    func free(ptr: CPointer<Unit>): Unit
8
}

`Annotation`#

1
annotationList: annotation+;
2

3
annotation
4
    : AT (identifier NL* DOT)* identifier (LSQUARE NL* annotationArgumentList NL* RSQUARE)?
5
    ;
6

7
annotationArgumentList
8
    : annotationArgument (NL* COMMA NL* annotationArgument)* NL* COMMA?
9
    ;
10

11
annotationArgument
12
    : identifier NL* COLON NL* expression
13
    | expression
14
    ;

1
@Test1
2
func myTest() {}
3

4
@Test2("Use newFunc() instead")
5
func oldFunc() {}
6

7
@Test3(name: "Alice", email: "alice@example.com")
8
class MyClass {}
9

10
@Test4([READ, WRITE])
11
class Document {}

宏声明#

1
macroDefinition
2
    : PUBLIC NL* MACRO NL* identifier NL*
3
    (macroWithoutAttrParam | macroWithAttrParam) NL*
4
    (COLON NL* identifier NL*)?
5
    (ASSIGN NL* expression | block)
6
    ;
7

8
macroWithoutAttrParam
9
    : LPAREN NL* macroInputDecl NL* RPAREN
10
    ;
11

12
macroWithAttrParam
13
    : LPAREN NL* macroAttrDecl NL* COMMA NL* macroInputDecl NL* RPAREN
14
    ;
15

16
macroInputDecl
17
    : identifier NL* COLON NL* identifier
18
    ;
19

20
macroAttrDecl
21
    : identifier NL* COLON NL* identifier
22
    ;

1
macro Empty(input: Tokens) {}
2

3
public macro Log(input: Tokens): Tokens {
4
    quote(println("[LOG] ${$(input)}"))
5
}
6

7
public macro Validate(attr: Tokens, input: Tokens): Tokens {
8
    quote(attr + x)
9
}

属性定义#

1
propertyDefinition
2
    : propertyModifier* NL* PROP NL* identifier NL* COLON NL* type NL* propertyBody?
3
    ;
4

5
propertyBody
6
    : LCURL end* propertyMemberDeclaration+ end* RCURL
7
    ;
8

9
propertyMemberDeclaration
10
    : GET NL* LPAREN RPAREN NL* block end*
11
    | SET NL* LPAREN identifier RPAREN NL* block end*
12
    ;
13

14
propertyModifier
15
    : PUBLIC
16
    | PRIVATE
17
    | PROTECTED
18
    | INTERNAL
19
    | STATIC
20
    | OPEN
21
    | OVERRIDE
22
    | REDEF
23
    | MUT
24
    ;

1
class User {
2
    prop username: String = "guest"
3
    prop isAdmin: Bool {
4
        get { username == "admin" }
5
    }
6
}

程序入口定义#

1
mainDefinition
2
    : MAIN
3
      NL* functionParameters
4
      (NL* COLON NL* type)?
5
      NL* block
6
    ;

1
main() {}
2

3
main(args: Array<String>): Int32 {
4
    if (args.size == 0) {
5
        println("Need arguments")
6
        return 1
7
    }
8
    return 0
9
}

类型#

1
type
2
    : arrowType
3
    | tupleType
4
    | prefixType
5
    | atomicType
6
    ;
7

8
arrowType
9
    : arrowParameters NL* ARROW NL* type
10
    ;
11

12
arrowParameters
13
    : LPAREN NL* (type (NL* COMMA NL* type)* NL*)? RPAREN
14
    ;
15

16
tupleType
17
    : LPAREN NL* type (NL* COMMA NL* type)+ NL* RPAREN
18
    ;
19

20
prefixType
21
    : prefixTypeOperator type
22
    ;
23

24
prefixTypeOperator
25
    : QUEST
26
    ;
27

28
atomicType
29
    : charLangTypes
30
    | userType
31
    | parenthesizedType
32
    ;
33

34
charLangTypes
35
    : numericTypes
36
    | RUNE
37
    | BOOLEAN
38
    | Nothing
39
    | UNIT
40
    | THISTYPE
41
    ;
42

43
numericTypes
44
    : INT8
45
    | INT16
46
    | INT32
47
    | INT64
48
    | INTNATIVE
49
    | UINT8
50
    | UINT16
51
    | UINT32
52
    | UINT64
53
    | UINTNATIVE
54
    | FLOAT16
55
    | FLOAT32
56
    | FLOAT64
57
    ;
58

59
userType
60
    : (identifier NL* DOT NL*)* identifier ( NL* typeArguments)?
61
    ;
62

63
parenthesizedType
64
    : LPAREN NL* type NL* RPAREN
65
    ;

表达式语法#

1
expression
2
    : assignmentExpression
3
    ;
4

5
assignmentExpression
6
    : leftValueExpressionWithoutWildCard NL* assignmentOperator NL* flowExpression
7
    | leftValueExpression NL* ASSIGN NL* flowExpression
8
    | tupleLeftValueExpression NL* ASSIGN NL* flowExpression
9
    | flowExpression
10
    ;
11

12
tupleLeftValueExpression
13
    : LPAREN NL* (leftValueExpression | tupleLeftValueExpression) (NL* COMMA NL* (leftValueExpression | tupleLeftValueExpression))+ NL* COMMA? NL* RPAREN
14
    ;
15

16
leftValueExpression
17
    : leftValueExpressionWithoutWildCard
18
    | WILDCARD
19
    ;
20

21
leftValueExpressionWithoutWildCard
22
    : identifier
23
    | leftAuxExpression QUEST? NL* assignableSuffix
24
    ;
25

26
leftAuxExpression
27
    : identifier (NL* typeArguments)?
28
    | type
29
    | thisSuperExpression
30
    | leftAuxExpression QUEST? NL* DOT NL* identifier (NL* typeArguments)?
31
    | leftAuxExpression QUEST? callSuffix
32
    | leftAuxExpression QUEST? indexAccess
33
    ;
34

35
assignableSuffix
36
    : fieldAccess
37
    | indexAccess
38
    ;
39

40
fieldAccess
41
    : NL* DOT NL* identifier
42
    ;
43

44
flowExpression
45
    : coalescingExpression (NL* flowOperator NL* coalescingExpression)*
46
    ;
47

48
coalescingExpression
49
    : logicDisjunctionExpression (NL* QUEST QUEST NL* logicDisjunctionExpression)*
50
    ;
51

52
logicDisjunctionExpression
53
    : logicConjunctionExpression (NL* OR NL* logicConjunctionExpression)*
54
    ;
55

56
logicConjunctionExpression
57
    : rangeExpression (NL* AND NL* rangeExpression)*
58
    ;
59

60
rangeExpression
61
    : bitwiseDisjunctionExpression NL* (CLOSEDRANGEOP | RANGEOP) NL* bitwiseDisjunctionExpression (NL* COLON NL* bitwiseDisjunctionExpression)?
62
    | bitwiseDisjunctionExpression
63
    ;
64

65
bitwiseDisjunctionExpression
66
    : bitwiseXorExpression (NL* BITOR NL* bitwiseXorExpression)*
67
    ;
68

69
bitwiseXorExpression
70
    : bitwiseConjunctionExpression (NL* BITXOR NL* bitwiseConjunctionExpression)*
71
    ;
72

73
bitwiseConjunctionExpression
74
    : equalityComparisonExpression (NL* BITAND NL* equalityComparisonExpression)*
75
    ;
76

77
equalityComparisonExpression
78
    : comparisonOrTypeExpression (NL* equalityOperator NL* comparisonOrTypeExpression)?
79
    ;
80

81
comparisonOrTypeExpression
82
    : shiftingExpression (NL* comparisonOperator NL* shiftingExpression)?
83
    | shiftingExpression (NL* IS NL* type)?
84
    | shiftingExpression (NL* AS NL* type)?
85
    ;
86

87
shiftingExpression
88
    : additiveExpression (NL* shiftingOperator NL* additiveExpression)*
89
    ;
90

91
additiveExpression
92
    : multiplicativeExpression (NL* additiveOperator NL* multiplicativeExpression)*
93
    ;
94

95
multiplicativeExpression
96
    : exponentExpression (NL* multiplicativeOperator NL* exponentExpression)*
97
    ;
98

99
exponentExpression
100
    : prefixUnaryExpression (NL* exponentOperator NL* prefixUnaryExpression)*
101
    ;
102

103
prefixUnaryExpression
104
    : prefixUnaryOperator* incAndDecExpression
105
    ;
106

107
incAndDecExpression
108
    : postfixExpression (INC | DEC )?
109
    ;
110

111
postfixExpression
112
     : atomicExpression
113
     | type NL* DOT NL* identifier
114
     | postfixExpression NL* DOT NL* identifier (NL* typeArguments)?
115
     | postfixExpression callSuffix
116
     | postfixExpression indexAccess
117
     | postfixExpression NL* DOT NL* identifier callSuffix? trailingLambdaExpression
118
     | identifier callSuffix? trailingLambdaExpression
119
     | postfixExpression (QUEST questSeperatedItems)+
120
     ;
121

122
questSeperatedItems
123
     : questSeperatedItem+
124
     ;
125

126
questSeperatedItem
127
     : itemAfterQuest (callSuffix | callSuffix? trailingLambdaExpression | indexAccess)?
128
     ;
129

130
itemAfterQuest
131
     : DOT identifier (NL* typeArguments)?
132
     | callSuffix
133
     | indexAccess
134
     | trailingLambdaExpression
135
     ;
136

137
callSuffix
138
    : LPAREN NL* (valueArgument (NL* COMMA NL* valueArgument)* NL*)? RPAREN
139
    ;
140

141
valueArgument
142
    : identifier NL* COLON NL* expression
143
    | expression
144
    | refTransferExpression
145
    ;
146

147
refTransferExpression
148
    : INOUT (expression DOT)? identifier
149
    ;
150

151
indexAccess
152
    : LSQUARE NL* (expression | rangeElement) NL* RSQUARE
153
    ;
154

155
rangeElement
156
    :  RANGEOP
157
    | ( CLOSEDRANGEOP | RANGEOP ) NL* expression
158
    | expression NL* RANGEOP
159
    ;
160

161
atomicExpression
162
    : literalConstant
163
    | collectionLiteral
164
    | tupleLiteral
165
    | identifier (NL* typeArguments)?
166
    | unitLiteral
167
    | ifExpression
168
    | matchExpression
169
    | loopExpression
170
    | tryExpression
171
    | jumpExpression
172
    | numericTypeConvExpr
173
    | thisSuperExpression
174
    | spawnExpression
175
    | synchronizedExpression
176
    | parenthesizedExpression
177
    | lambdaExpression
178
    | quoteExpression
179
    | macroExpression
180
    | unsafeExpression
181
    ;
182

183
literalConstant
184
    : IntegerLiteral
185
    | FloatLiteral
186
    | RuneLiteral
187
    | ByteLiteral
188
    | booleanLiteral
189
    | stringLiteral
190
    | ByteStringArrayLiteral
191
    | unitLiteral
192
    ;
193

194
booleanLiteral
195
    : TRUE
196
    | FALSE
197
    ;
198

199
stringLiteral
200
    : lineStringLiteral
201
    | multiLineStringLiteral
202
    | MultiLineRawStringLiteral
203
    ;
204

205
lineStringContent
206
    :  LineStrText
207
    ;
208

209
lineStringLiteral
210
    : QUOTE_OPEN (lineStringExpression | lineStringContent)* QUOTE_CLOSE
211
    ;
212

213
lineStringExpression
214
    : LineStrExprStart SEMI* (expressionOrDeclaration (SEMI+ expressionOrDeclaration?)*) SEMI* RCURL
215
    ;
216

217
multiLineStringContent
218
    : MultiLineStrText
219
    ;
220

221
multiLineStringLiteral
222
    : TRIPLE_QUOTE_OPEN (multiLineStringExpression | multiLineStringContent)* TRIPLE_QUOTE_CLOSE
223
    ;
224

225
multiLineStringExpression
226
    : MultiLineStrExprStart end* (expressionOrDeclaration (end+ expressionOrDeclaration?)*) end* RCURL
227
    ;
228

229
collectionLiteral
230
    : arrayLiteral
231
    ;
232

233
arrayLiteral
234
    : LSQUARE (NL* elements)? NL* RSQUARE
235
    ;
236

237
elements
238
    : element ( NL* COMMA NL* element )*
239
    ;
240

241
element
242
    : expressionElement
243
    | spreadElement
244
    ;
245

246
expressionElement
247
    : expression
248
    ;
249

250
spreadElement
251
    : MUL expression
252
    ;
253

254
tupleLiteral
255
    : LPAREN NL* expression (NL* COMMA NL*expression)+ NL* RPAREN
256
    ;
257

258
unitLiteral
259
    : LPAREN NL* RPAREN
260
    ;
261

262
ifExpression
263
    : IF NL* LPAREN NL* (LET NL* deconstructPattern NL* BACKARROW NL*)? expression NL* RPAREN NL* block
264
    (NL* ELSE (NL* ifExpression | NL* block))?
265
    ;
266

267
deconstructPattern
268
    : constantPattern
269
    | wildcardPattern
270
    | varBindingPattern
271
    | tuplePattern
272
    | enumPattern
273
    ;
274

275
matchExpression
276
    : MATCH NL* LPAREN NL* expression NL* RPAREN NL* LCURL NL* matchCase+ NL* RCURL
277
    | MATCH NL* LCURL NL* (CASE NL* (expression | WILDCARD) NL* DOUBLE_ARROW NL* expressionOrDeclaration (end+ expressionOrDeclaration?)*)+ NL* RCURL
278
    ;
279

280
matchCase
281
    : CASE NL* pattern NL* patternGuard? NL* DOUBLE_ARROW NL* expressionOrDeclaration (end+ expressionOrDeclaration?)*
282
    ;
283

284
patternGuard
285
    : WHERE NL* expression
286
    ;
287

288
pattern
289
   : constantPattern
290
   | wildcardPattern
291
   | varBindingPattern
292
   | tuplePattern
293
   | typePattern
294
   | enumPattern
295
   ;
296

297
constantPattern
298
   : literalConstant NL* ( NL* BITOR NL* literalConstant)*
299
   ;
300

301
wildcardPattern
302
   : WILDCARD
303
   ;
304

305
varBindingPattern
306
   : identifier
307
   ;
308

309
tuplePattern
310
   : LPAREN NL* pattern (NL* COMMA NL* pattern)+ NL* RPAREN
311
   ;
312

313
typePattern
314
   : (WILDCARD | identifier) NL* COLON NL* type
315
   ;
316

317
enumPattern
318
   : NL* ((userType NL* DOT NL*)? identifier enumPatternParameters?) (NL* BITOR NL* ((userType NL* DOT NL*)? identifier enumPatternParameters?))*
319
   ;
320

321
enumPatternParameters
322
   : LPAREN NL* pattern (NL* COMMA NL* pattern)* NL* RPAREN
323
   ;
324

325
loopExpression
326
    : forInExpression
327
    | whileExpression
328
    | doWhileExpression
329
    ;
330

331
forInExpression
332
    : FOR NL* LPAREN NL* patternsMaybeIrrefutable NL* IN NL* expression NL* patternGuard? NL* RPAREN NL* block
333
    ;
334

335
patternsMaybeIrrefutable
336
    : wildcardPattern
337
    | varBindingPattern
338
    | tuplePattern
339
    | enumPattern
340
    ;
341

342
whileExpression
343
    : WHILE NL* LPAREN NL* (LET NL* deconstructPattern NL* BACKARROW NL*)? expression NL* RPAREN NL* block
344
    ;
345

346
doWhileExpression
347
    : DO NL* block NL* WHILE NL* LPAREN NL* expression NL* RPAREN
348
    ;
349

350
tryExpression
351
    : TRY NL* block NL* FINALLY NL* block
352
    | TRY NL* block (NL* CATCH NL* LPAREN NL* catchPattern NL* RPAREN NL* block)+ (NL* FINALLY NL* block)?
353
    | TRY NL* LPAREN NL* resourceSpecifications NL* RPAREN NL* block
354
    (NL* CATCH NL* LPAREN NL* catchPattern NL* RPAREN NL* block)* (NL* FINALLY NL* block)?
355
    ;
356

357
catchPattern
358
    : wildcardPattern
359
    | exceptionTypePattern
360
    ;
361

362
exceptionTypePattern
363
    : (WILDCARD | identifier) NL* COLON NL* type (NL* BITOR NL* type)*
364
    ;
365

366
resourceSpecifications
367
    : resourceSpecification (NL* COMMA NL* resourceSpecification)*
368
    ;
369

370
resourceSpecification
371
    : identifier (NL* COLON NL* classType)? NL* ASSIGN NL* expression
372
    ;
373

374
jumpExpression
375
    : THROW NL* expression
376
    | RETURN (NL* expression)?
377
    | CONTINUE
378
    | BREAK
379
    ;
380

381
numericTypeConvExpr
382
    : numericTypes LPAREN NL* expression NL* RPAREN
383
    ;
384

385
thisSuperExpression
386
    : THIS
387
    | SUPER
388
    ;
389

390
lambdaExpression
391
    : LCURL NL* lambdaParameters? NL* DOUBLE_ARROW NL* expressionOrDeclarations? RCURL
392
    ;
393

394
trailingLambdaExpression
395
    : LCURL NL* (lambdaParameters? NL* DOUBLE_ARROW NL*)? expressionOrDeclarations? RCURL
396
    ;
397

398
lambdaParameters
399
    : lambdaParameter (NL* COMMA NL* lambdaParameter)*
400
    ;
401

402
lambdaParameter
403
    : (identifier | WILDCARD) (NL* COLON NL* type)?
404
    ;
405

406
spawnExpression
407
    : SPAWN (LPAREN NL* expression NL* RPAREN)? NL* trailingLambdaExpression
408
    ;
409

410
synchronizedExpression
411
    : SYNCHRONIZED LPAREN NL* expression NL* RPAREN NL* block
412
    ;
413

414
parenthesizedExpression
415
    : LPAREN NL* expression NL* RPAREN
416
    ;
417

418
block
419
    : LCURL expressionOrDeclarations RCURL
420
    ;
421

422
unsafeExpression
423
    : UNSAFE NL* block
424
    ;
425

426
expressionOrDeclarations
427
    : end* (expressionOrDeclaration (end+ expressionOrDeclaration?)*)?
428
    ;
429

430
expressionOrDeclaration
431
    : expression
432
    | varOrfuncDeclaration
433
    ;
434

435
varOrfuncDeclaration
436
    : functionDefinition
437
    | variableDeclaration
438
    ;
439

440
quoteExpression
441
    : QUOTE quoteExpr
442
    ;
443

444
quoteExpr
445
    : LPAREN NL* quoteParameters NL* RPAREN
446
    ;
447

448
quoteParameters
449
    : (NL* quoteToken | NL* quoteInterpolate | NL* macroExpression)+
450
    ;
451

452
quoteToken
453
    : DOT | COMMA | LPAREN | RPAREN | LSQUARE | RSQUARE | LCURL | RCURL | EXP | MUL | MOD | DIV | ADD | SUB
454
    | PIPELINE | COMPOSITION
455
    | INC | DEC | AND | OR | NOT | BITAND | BITOR | BITXOR | LSHIFT | RSHIFT | COLON | SEMI
456
    | ASSIGN | ADD_ASSIGN | SUB_ASSIGN | MUL_ASSIGN | EXP_ASSIGN | DIV_ASSIGN | MOD_ASSIGN
457
    | AND_ASSIGN | OR_ASSIGN | BITAND_ASSIGN | BITOR_ASSIGN | BITXOR_ASSIGN | LSHIFT_ASSIGN | RSHIFT_ASSIGN
458
    | ARROW | BACKARROW | DOUBLE_ARROW | ELLIPSIS | CLOSEDRANGEOP | RANGEOP | HASH | AT | QUEST | UPPERBOUND | LT | GT | LE | GE
459
    | NOTEQUAL | EQUAL | WILDCARD | BACKSLASH | QUOTESYMBOL | DOLLAR
460
    | INT8 | INT16 | INT32 | INT64 | INTNATIVE | UINT8 | UINT16 | UINT32 | UINT64 | UINTNATIVE | FLOAT16
461
    | FLOAT32 | FLOAT64 | RUNE | BOOL | UNIT | NOTHING | STRUCT | ENUM | THIS
462
    | PACKAGE | IMPORT | CLASS | INTERFACE | FUNC | LET | VAR | CONST | TYPE
463
    | INIT | THIS | SUPER | IF | ELSE | CASE | TRY | CATCH | FINALLY
464
    | FOR | DO | WHILE | THROW | RETURN | CONTINUE | BREAK | AS | IN
465
    | MATCH | FROM | WHERE | EXTEND | SPAWN | SYNCHRONIZED | MACRO | QUOTE | TRUE | FALSE
466
    | STATIC | PUBLIC | PRIVATE | PROTECTED
467
    | OVERRIDE | ABSTRACT | OPEN | OPERATOR | FOREIGN
468
    | Identifier | DollarIdentifier
469
    | literalConstant
470
    ;
471

472
quoteInterpolate
473
    : DOLLAR LPAREN NL* expression NL* RPAREN
474
    ;
475

476
macroExpression
477
    : AT Identifier macroAttrExpr? NL* (macroInputExprWithoutParens | macroInputExprWithParens)
478
    ;
479

480
macroAttrExpr
481
    : LSQUARE NL* quoteToken* NL* RSQUARE
482
    ;
483

484
macroInputExprWithoutParens
485
    : functionDefinition
486
    | operatorFunctionDefinition
487
    | staticInit
488
    | structDefinition
489
    | structPrimaryInit
490
    | structInit
491
    | enumDefinition
492
    | caseBody
493
    | classDefinition
494
    | classPrimaryInit
495
    | classInit
496
    | interfaceDefinition
497
    | variableDeclaration
498
    | propertyDefinition
499
    | extendDefinition
500
    | macroExpression
501
    ;
502

503
macroInputExprWithParens
504
    : LPAREN NL* macroTokens NL* RPAREN
505
    ;
506

507
macroTokens
508
    : (quoteToken | macroExpression)*
509
    ;
510

511
assignmentOperator
512
    : ASSIGN
513
    | ADD_ASSIGN
514
    | SUB_ASSIGN
515
    | EXP_ASSIGN
516
    | MUL_ASSIGN
517
    | DIV_ASSIGN
518
    | MOD_ASSIGN
519
    | AND_ASSIGN
520
    | OR_ASSIGN
521
    | BITAND_ASSIGN
522
    | BITOR_ASSIGN
523
    | BITXOR_ASSIGN
524
    | LSHIFT_ASSIGN
525
    | RSHIFT_ASSIGN
526
    ;
527

528
equalityOperator
529
    : NOTEQUAL
530
    | EQUAL
531
    ;
532

533
comparisonOperator
534
    : LT
535
    | GT
536
    | LE
537
    | GE
538
    ;
539

540
shiftingOperator
541
    : LSHIFT | RSHIFT
542
    ;
543

544
flowOperator
545
    : PIPELINE | COMPOSITION
546
    ;
547

548
additiveOperator
549
    : ADD | SUB
550
    ;
551

552
exponentOperator
553
    : EXP
554
    ;
555

556
multiplicativeOperator
557
    : MUL
558
    | DIV
559
    | MOD
560
    ;
561

562
prefixUnaryOperator
563
    : SUB
564
    | NOT
565
    ;
566

567
overloadedOperators
568
    : LSQUARE RSQUARE
569
    | NOT
570
    | ADD
571
    | SUB
572
    | EXP
573
    | MUL
574
    | DIV
575
    | MOD
576
    | LSHIFT
577
    | RSHIFT
578
    | LT
579
    | GT
580
    | LE
581
    | GE
582
    | EQUAL
583
    | NOTEQUAL
584
    | BITAND
585
    | BITXOR
586
    | BITOR
587
    ;

仓颉语法#

词法#

注释#

空白和换行#

符号#

关键字#

字面量#

标识符#

语法#

编译单元#

包定义和包导入#

top-level 定义#

class 定义#

interface 定义#

function 定义#

变量定义#

enum 定义#

struct 定义#

类型别名定义#

扩展定义#

foreign 声明#

Annotation#

宏声明#

属性定义#

程序入口定义#

类型#

表达式语法#

`top-level` 定义#

`class` 定义#

`interface` 定义#

`function` 定义#

`enum` 定义#

`struct` 定义#

`foreign` 声明#

`Annotation`#