Update to moonbit v0.1.20250423+2af95d42c

nathsou · nathsou · commit c7d0c40ca489 · 2025-04-25T19:06:48.000+02:00
diff --git a/moon.mod.json b/moon.mod.json
@@ -2,7 +2,7 @@
   "name": "nathsou/smb",
   "version": "0.1.0",
   "deps": {
-    "moonbitlang/x": "0.4.11"
+    "moonbitlang/x": "0.4.26"
   },
   "readme": "README.md",
   "repository": "",
diff --git a/src/lower/lower.mbt b/src/lower/lower.mbt
@@ -14,7 +14,7 @@ pub(all) struct AsmLowering {
   flat_subroutines: Array[AsmFlatSubroutine]
 } derive (Show)
 
-pub(readonly) type! LoweringError String derive(Show)
+pub type! LoweringError String derive(Show)
 
 pub fn AsmLowering::new(items: Array[@parse.SourceItem]) -> AsmLowering {
   {
@@ -312,7 +312,7 @@ fn collect_jump_targets(self: AsmLowering) -> Unit {
       }
       Label(name) => {
         // manually annotated subroutines
-        if name.ends_with("__sub") {
+        if name.has_suffix("__sub") {
           self.targets.subroutines.add(name)
         }
       }
@@ -379,7 +379,7 @@ fn collect_basic_block_leaders(self: AsmLowering) -> Array[Int] {
   leader_indices
 }
 
-struct ItemInfo {
+priv struct ItemInfo {
   item: AsmItem
   index: Int
 }
@@ -472,7 +472,7 @@ fn collect_basic_blocks(self: AsmLowering) -> Unit!LoweringError {
             connect(bb, target_bb, false)
           }
           None => {
-            if not(label.starts_with("__")) { // allow special labels
+            if not(label.has_prefix("__")) { // allow special labels
               raise LoweringError("Unknown jump target: \{label}")
             }
           }
@@ -485,7 +485,7 @@ fn collect_basic_blocks(self: AsmLowering) -> Unit!LoweringError {
               connect(bb, target_bb, false)
             }
             None => {
-              if not(label.starts_with("__")) { // allow special labels
+              if not(label.has_prefix("__")) { // allow special labels
                 raise LoweringError("Unknown jump target: \{label}")
               }
             }
@@ -591,7 +591,7 @@ fn rewrite_bb(self: AsmLowering, bb: BasicBlock, visited: Set[Int]) -> Unit!Lowe
 }
 
 pub fn is_subroutine_label(self: AsmLowering, label: String) -> Bool {
-  self.targets.subroutines.contains(label) || label.ends_with("__sub")
+  self.targets.subroutines.contains(label) || label.has_suffix("__sub")
 }
 
 fn collect_subroutines(self: AsmLowering) -> Unit!LoweringError {
@@ -677,7 +677,7 @@ fn  _cfg_dotfile(self: AsmLowering) -> String {
   builder.to_string()
 }
 
-struct ControlFlowStackEntry {
+priv struct ControlFlowStackEntry {
   exit_label: String
   cond: @parse.OpCode
   body: Array[AsmItem]
diff --git a/src/main/main.mbt b/src/main/main.mbt
@@ -7,7 +7,7 @@ type! PipelineError {
 } derive(Show)
 
 fn read_rom() -> String!PipelineError {
-  match @fs.read_file_to_string?(path="src/smb.asm") {
+  match @fs.read_file_to_string?("src/smb.asm") {
     Ok(asm) => asm
     Err(err) => raise IOError(Show::to_string(err))
   }
@@ -53,23 +53,32 @@ fn transpile() -> @transpile.Transpiler!PipelineError {
 let lib_output_dir: String = "out/lib"
 let output_dir: String = "out"
 
-fn main {
-  if not(@fs.path_exists(path=output_dir)) {
-    @fs.create_dir(path=output_dir)
+fn run() -> Unit!Error {
+  if not(@fs.path_exists(output_dir)) {
+    @fs.create_dir!(output_dir)
   }
 
-  if not(@fs.path_exists(path=lib_output_dir)) {
-    @fs.create_dir(path=lib_output_dir)
+  if not(@fs.path_exists(lib_output_dir)) {
+    @fs.create_dir!(lib_output_dir)
   }
 
   match transpile?() {
       Ok(tr) => {
           for file in tr.files {
-              file.write(dir=if file.is_lib { lib_output_dir } else { output_dir })
+              file.write!(dir=if file.is_lib { lib_output_dir } else { output_dir })
           }
       }
       Err(err) => {
           println(err)
       }
   }
 }
+
+fn main {
+  match run?() {
+    Ok(_) => ()
+    Err(err) => {
+      println("Error: \{Show::to_string(err)}")
+    }
+  }
+}
diff --git a/src/parse/lex.mbt b/src/parse/lex.mbt
@@ -4,7 +4,7 @@ pub(all) struct Lexer {
   mut index: Int
 }
 
-pub(readonly) type! LexerError {
+pub type! LexerError {
   UnexepectedChar(char~: Char, index~: Int)
   InvalidConstant(lexeme~: String, base~: ConstantBase)
 } derive(Show)
@@ -117,9 +117,14 @@ fn parse_constant(self: Lexer, base~: ConstantBase) -> LexerResult {
 
   let lexeme = lexeme.to_string()
 
-  let value = match @strconv.parse_int?(lexeme, base=base.to_int()) {
-    Ok(value) => value
-    Err(_) => return Grr(InvalidConstant(lexeme~, base~))
+  let value = match (lexeme, base) {
+    ("0b", Hexadecimal) => 11 // https://github.com/moonbitlang/core/issues/2006
+    _ => {
+      match @strconv.parse_int?(lexeme, base=base.to_int()) {
+        Ok(value) => value
+        Err(_) => return Grr(InvalidConstant(lexeme~, base~))
+      }
+    }
   }
 
   let size = match base {
@@ -285,7 +290,7 @@ fn advance(self: Lexer) -> Unit {
   self.index += 1
 }
 
-enum LexerResult {
+priv enum LexerResult {
   Yay(Token)
   Grr(LexerError)
   EOF
diff --git a/src/parse/parse.mbt b/src/parse/parse.mbt
@@ -4,7 +4,7 @@ pub(all) struct Parser {
   mut index: Int
 }
 
-pub(readonly) type! ParserError {
+pub type! ParserError {
   UnexpectedToken(expected~: Token, received~: Token)
   ExpectedIdentifier(Token)
   ExpectedExpr(Token)
@@ -15,15 +15,15 @@ pub fn Parser::new(tokens: Array[Token]) -> Parser {
   { tokens, index: 0, defines: {} }
 }
 
-fn peek(self: Parser) -> Token {
+fn Parser::peek(self: Parser) -> Token {
   self.tokens[self.index]
 }
 
-fn lookahead(self: Parser, n: Int) -> Token {
+fn Parser::lookahead(self: Parser, n: Int) -> Token {
   self.tokens[self.index + n]
 }
 
-fn advance(self: Parser) -> Unit {
+fn Parser::advance(self: Parser) -> Unit {
   self.index += 1
 }
 
@@ -36,15 +36,15 @@ fn expect(self: Parser, expected: Token) -> Unit!ParserError {
   }
 }
 
-fn matches(self: Parser, token: Token) -> Bool {
+fn Parser::matches(self: Parser, token: Token) -> Bool {
   self.peek() == token
 }
 
 fn matches_predicate(self: Parser, predicate: (Token) -> Bool) -> Bool {
   predicate(self.peek())
 }
 
-fn consumes(self: Parser, token: Token) -> Bool {
+fn Parser::consumes(self: Parser, token: Token) -> Bool {
   if self.matches(token) {
     self.advance()
     true
@@ -53,12 +53,12 @@ fn consumes(self: Parser, token: Token) -> Bool {
   }
 }
 
-fn consumeIfPresent(self: Parser, token: Token) -> Unit {
+fn Parser::consumeIfPresent(self: Parser, token: Token) -> Unit {
   let _ = self.consumes(token)
 
 }
 
-fn parse_identifier(self: Parser) -> String!ParserError {
+fn Parser::parse_identifier(self: Parser) -> String!ParserError {
   let token = self.peek()
   match token {
     Identifier(name) => {
@@ -69,7 +69,7 @@ fn parse_identifier(self: Parser) -> String!ParserError {
   }
 }
 
-fn parse_primary_expr(self: Parser) -> SourceExpr!ParserError {
+fn Parser::parse_primary_expr(self: Parser) -> SourceExpr!ParserError {
   let token = self.peek()
   match token {
     Constant(base~, value~, size~) => {
@@ -100,7 +100,7 @@ fn parse_primary_expr(self: Parser) -> SourceExpr!ParserError {
   }
 }
 
-fn parse_additive_expr(self: Parser) -> SourceExpr!ParserError {
+fn Parser::parse_additive_expr(self: Parser) -> SourceExpr!ParserError {
   let mut lhs = self.parse_primary_expr!()
   while true {
     if self.consumes(Plus) {
@@ -116,11 +116,11 @@ fn parse_additive_expr(self: Parser) -> SourceExpr!ParserError {
   lhs
 }
 
-fn parse_expr(self: Parser) -> SourceExpr!ParserError {
+fn Parser::parse_expr(self: Parser) -> SourceExpr!ParserError {
   self.parse_additive_expr!()
 }
 
-fn parse_directive_args(self: Parser) -> Array[SourceExpr]!ParserError {
+fn Parser::parse_directive_args(self: Parser) -> Array[SourceExpr]!ParserError {
   let args: Array[SourceExpr] = []
   while true {
     let expr = self.parse_expr!()
@@ -132,7 +132,7 @@ fn parse_directive_args(self: Parser) -> Array[SourceExpr]!ParserError {
   args
 }
 
-fn parse_addressing_mode(
+fn Parser::parse_addressing_mode(
   self: Parser,
   opcode~: OpCode
 ) -> SourceAddressingMode!ParserError {
@@ -200,7 +200,7 @@ fn parse_addressing_mode(
   }
 }
 
-fn parse_inst(self: Parser) -> SourceItem!ParserError {
+fn Parser::parse_inst(self: Parser) -> SourceItem!ParserError {
   let token = self.peek()
 
   match token {
@@ -232,7 +232,7 @@ fn parse_inst(self: Parser) -> SourceItem!ParserError {
   }
 }
 
-pub fn parse(self: Parser) -> Array[SourceItem]!ParserError {
+pub fn Parser::parse(self: Parser) -> Array[SourceItem]!ParserError {
   let insts: Array[SourceItem] = []
 
   while self.index < self.tokens.length() {
diff --git a/src/parse/token.mbt b/src/parse/token.mbt
@@ -31,7 +31,7 @@ enum Token {
   RightChevron
 } derive (Show, Eq)
 
-fn to_int(self: ConstantBase) -> Int {
+fn ConstantBase::to_int(self: ConstantBase) -> Int {
   match self {
     Binary => 2
     Decimal => 10
diff --git a/src/transpile/transpile.mbt b/src/transpile/transpile.mbt
@@ -147,7 +147,7 @@ fn emit_data_c(self: Emitter, low: @lower.AsmLowering) -> Unit {
     for line in table.lines {
       match line {
         Data(data~, comment~) => {
-          let data = String::concat(data.map(show_expr), separator=", ")
+          let data = @string.concat(data.map(show_expr), separator=", ")
 
           match comment.val {
             "" => self.emit(data + ",")
@@ -185,8 +185,8 @@ fn emit_code_h(self: Emitter, low: @lower.AsmLowering) -> Unit {
 }
 
 fn rename_label(label: String) -> String {
-  if label.ends_with("__sub") {
-    label.split("__sub").iter().peek().unwrap()
+  if label.has_suffix("__sub") {
+    label.split("__sub").iter().peek().unwrap().to_string()
   } else {
     label
   }
@@ -221,15 +221,15 @@ fn show_cond_opcode(op: @parse.OpCode) -> String {
   }
 }
 
-enum Reg { A; X; Y }
-struct Range { min: Int; max: Int }
+priv enum Reg { A; X; Y }
+priv struct Range { min: Int; max: Int }
 
-fn op_add(self: Range, other: Range) -> Range {
+impl Add for Range with op_add(self: Range, other: Range) -> Range {
   { min: self.min + other.min, max: self.max + other.max }
 }
 
-fn op_sub(self: Range, other: Range) -> Range {
-  { min: self.min - other.max, max: self.max - other.min }
+impl Sub for Range with op_sub(self: Range, other: Range) -> Range {
+  { min: self.min - other.min, max: self.max - other.max }
 }
 
 fn compute_expr_range(expr: @lower.TypedExpr, low: @lower.AsmLowering) -> Range? {
@@ -498,12 +498,12 @@ pub(all) struct File {
 }
 
 fn File::read(name~: String, path~: String, is_lib~: Bool = true) -> File!Error {
-  let contents = @fs.read_file_to_string!(path~)
+  let contents = @fs.read_file_to_string!(path)
   { name, contents, is_lib }
 }
 
-pub fn write(self: File, dir~: String) -> Unit {
-  @fs.write_string_to_file(path="\{dir}/\{self.name}", content=self.contents)
+pub fn File::write(self: File, dir~: String) -> Unit!Error {
+  @fs.write_string_to_file!("\{dir}/\{self.name}", self.contents)
 }
 
 pub(all) struct Transpiler {

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ pub(all) struct AsmLowering {`
`14`	`14`	`flat_subroutines: Array[AsmFlatSubroutine]`
`15`	`15`	`} derive (Show)`
`16`	`16`
`17`		`-pub(readonly) type! LoweringError String derive(Show)`
	`17`	`+pub type! LoweringError String derive(Show)`
`18`	`18`
`19`	`19`	`pub fn AsmLowering::new(items: Array[@parse.SourceItem]) -> AsmLowering {`
`20`	`20`	`{`
`@@ -312,7 +312,7 @@ fn collect_jump_targets(self: AsmLowering) -> Unit {`
`312`	`312`	`}`
`313`	`313`	`Label(name) => {`
`314`	`314`	`// manually annotated subroutines`
`315`		`- if name.ends_with("__sub") {`
	`315`	`+ if name.has_suffix("__sub") {`
`316`	`316`	`self.targets.subroutines.add(name)`
`317`	`317`	`}`
`318`	`318`	`}`
`@@ -379,7 +379,7 @@ fn collect_basic_block_leaders(self: AsmLowering) -> Array[Int] {`
`379`	`379`	`leader_indices`
`380`	`380`	`}`
`381`	`381`
`382`		`-struct ItemInfo {`
	`382`	`+priv struct ItemInfo {`
`383`	`383`	`item: AsmItem`
`384`	`384`	`index: Int`
`385`	`385`	`}`
`@@ -472,7 +472,7 @@ fn collect_basic_blocks(self: AsmLowering) -> Unit!LoweringError {`
`472`	`472`	`connect(bb, target_bb, false)`
`473`	`473`	`}`
`474`	`474`	`None => {`
`475`		`- if not(label.starts_with("__")) { // allow special labels`
	`475`	`+ if not(label.has_prefix("__")) { // allow special labels`
`476`	`476`	`raise LoweringError("Unknown jump target: \{label}")`
`477`	`477`	`}`
`478`	`478`	`}`
`@@ -485,7 +485,7 @@ fn collect_basic_blocks(self: AsmLowering) -> Unit!LoweringError {`
`485`	`485`	`connect(bb, target_bb, false)`
`486`	`486`	`}`
`487`	`487`	`None => {`
`488`		`- if not(label.starts_with("__")) { // allow special labels`
	`488`	`+ if not(label.has_prefix("__")) { // allow special labels`
`489`	`489`	`raise LoweringError("Unknown jump target: \{label}")`
`490`	`490`	`}`
`491`	`491`	`}`
`@@ -591,7 +591,7 @@ fn rewrite_bb(self: AsmLowering, bb: BasicBlock, visited: Set[Int]) -> Unit!Lowe`
`591`	`591`	`}`
`592`	`592`
`593`	`593`	`pub fn is_subroutine_label(self: AsmLowering, label: String) -> Bool {`
`594`		`- self.targets.subroutines.contains(label) \|\| label.ends_with("__sub")`
	`594`	`+ self.targets.subroutines.contains(label) \|\| label.has_suffix("__sub")`
`595`	`595`	`}`
`596`	`596`
`597`	`597`	`fn collect_subroutines(self: AsmLowering) -> Unit!LoweringError {`
`@@ -677,7 +677,7 @@ fn _cfg_dotfile(self: AsmLowering) -> String {`
`677`	`677`	`builder.to_string()`
`678`	`678`	`}`
`679`	`679`
`680`		`-struct ControlFlowStackEntry {`
	`680`	`+priv struct ControlFlowStackEntry {`
`681`	`681`	`exit_label: String`
`682`	`682`	`cond: @parse.OpCode`
`683`	`683`	`body: Array[AsmItem]`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ type! PipelineError {`
`7`	`7`	`} derive(Show)`
`8`	`8`
`9`	`9`	`fn read_rom() -> String!PipelineError {`
`10`		`- match @fs.read_file_to_string?(path="src/smb.asm") {`
	`10`	`+ match @fs.read_file_to_string?("src/smb.asm") {`
`11`	`11`	`Ok(asm) => asm`
`12`	`12`	`Err(err) => raise IOError(Show::to_string(err))`
`13`	`13`	`}`
`@@ -53,23 +53,32 @@ fn transpile() -> @transpile.Transpiler!PipelineError {`
`53`	`53`	`let lib_output_dir: String = "out/lib"`
`54`	`54`	`let output_dir: String = "out"`
`55`	`55`
`56`		`-fn main {`
`57`		`- if not(@fs.path_exists(path=output_dir)) {`
`58`		`- @fs.create_dir(path=output_dir)`
	`56`	`+fn run() -> Unit!Error {`
	`57`	`+ if not(@fs.path_exists(output_dir)) {`
	`58`	`+ @fs.create_dir!(output_dir)`
`59`	`59`	`}`
`60`	`60`
`61`		`- if not(@fs.path_exists(path=lib_output_dir)) {`
`62`		`- @fs.create_dir(path=lib_output_dir)`
	`61`	`+ if not(@fs.path_exists(lib_output_dir)) {`
	`62`	`+ @fs.create_dir!(lib_output_dir)`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`match transpile?() {`
`66`	`66`	`Ok(tr) => {`
`67`	`67`	`for file in tr.files {`
`68`		`- file.write(dir=if file.is_lib { lib_output_dir } else { output_dir })`
	`68`	`+ file.write!(dir=if file.is_lib { lib_output_dir } else { output_dir })`
`69`	`69`	`}`
`70`	`70`	`}`
`71`	`71`	`Err(err) => {`
`72`	`72`	`println(err)`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`	`}`
	`76`	`+`
	`77`	`+fn main {`
	`78`	`+ match run?() {`
	`79`	`+ Ok(_) => ()`
	`80`	`+ Err(err) => {`
	`81`	`+ println("Error: \{Show::to_string(err)}")`
	`82`	`+ }`
	`83`	`+ }`
	`84`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ pub(all) struct Parser {`
`4`	`4`	`mut index: Int`
`5`	`5`	`}`
`6`	`6`
`7`		`-pub(readonly) type! ParserError {`
	`7`	`+pub type! ParserError {`
`8`	`8`	`UnexpectedToken(expected~: Token, received~: Token)`
`9`	`9`	`ExpectedIdentifier(Token)`
`10`	`10`	`ExpectedExpr(Token)`
`@@ -15,15 +15,15 @@ pub fn Parser::new(tokens: Array[Token]) -> Parser {`
`15`	`15`	`{ tokens, index: 0, defines: {} }`
`16`	`16`	`}`
`17`	`17`
`18`		`-fn peek(self: Parser) -> Token {`
	`18`	`+fn Parser::peek(self: Parser) -> Token {`
`19`	`19`	`self.tokens[self.index]`
`20`	`20`	`}`
`21`	`21`
`22`		`-fn lookahead(self: Parser, n: Int) -> Token {`
	`22`	`+fn Parser::lookahead(self: Parser, n: Int) -> Token {`
`23`	`23`	`self.tokens[self.index + n]`
`24`	`24`	`}`
`25`	`25`
`26`		`-fn advance(self: Parser) -> Unit {`
	`26`	`+fn Parser::advance(self: Parser) -> Unit {`
`27`	`27`	`self.index += 1`
`28`	`28`	`}`
`29`	`29`
`@@ -36,15 +36,15 @@ fn expect(self: Parser, expected: Token) -> Unit!ParserError {`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`
`39`		`-fn matches(self: Parser, token: Token) -> Bool {`
	`39`	`+fn Parser::matches(self: Parser, token: Token) -> Bool {`
`40`	`40`	`self.peek() == token`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`fn matches_predicate(self: Parser, predicate: (Token) -> Bool) -> Bool {`
`44`	`44`	`predicate(self.peek())`
`45`	`45`	`}`
`46`	`46`
`47`		`-fn consumes(self: Parser, token: Token) -> Bool {`
	`47`	`+fn Parser::consumes(self: Parser, token: Token) -> Bool {`
`48`	`48`	`if self.matches(token) {`
`49`	`49`	`self.advance()`
`50`	`50`	`true`
`@@ -53,12 +53,12 @@ fn consumes(self: Parser, token: Token) -> Bool {`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
`56`		`-fn consumeIfPresent(self: Parser, token: Token) -> Unit {`
	`56`	`+fn Parser::consumeIfPresent(self: Parser, token: Token) -> Unit {`
`57`	`57`	`let _ = self.consumes(token)`
`58`	`58`
`59`	`59`	`}`
`60`	`60`
`61`		`-fn parse_identifier(self: Parser) -> String!ParserError {`
	`61`	`+fn Parser::parse_identifier(self: Parser) -> String!ParserError {`
`62`	`62`	`let token = self.peek()`
`63`	`63`	`match token {`
`64`	`64`	`Identifier(name) => {`
`@@ -69,7 +69,7 @@ fn parse_identifier(self: Parser) -> String!ParserError {`
`69`	`69`	`}`
`70`	`70`	`}`
`71`	`71`
`72`		`-fn parse_primary_expr(self: Parser) -> SourceExpr!ParserError {`
	`72`	`+fn Parser::parse_primary_expr(self: Parser) -> SourceExpr!ParserError {`
`73`	`73`	`let token = self.peek()`
`74`	`74`	`match token {`
`75`	`75`	`Constant(base~, value~, size~) => {`
`@@ -100,7 +100,7 @@ fn parse_primary_expr(self: Parser) -> SourceExpr!ParserError {`
`100`	`100`	`}`
`101`	`101`	`}`
`102`	`102`
`103`		`-fn parse_additive_expr(self: Parser) -> SourceExpr!ParserError {`
	`103`	`+fn Parser::parse_additive_expr(self: Parser) -> SourceExpr!ParserError {`
`104`	`104`	`let mut lhs = self.parse_primary_expr!()`
`105`	`105`	`while true {`
`106`	`106`	`if self.consumes(Plus) {`
`@@ -116,11 +116,11 @@ fn parse_additive_expr(self: Parser) -> SourceExpr!ParserError {`
`116`	`116`	`lhs`
`117`	`117`	`}`
`118`	`118`
`119`		`-fn parse_expr(self: Parser) -> SourceExpr!ParserError {`
	`119`	`+fn Parser::parse_expr(self: Parser) -> SourceExpr!ParserError {`
`120`	`120`	`self.parse_additive_expr!()`
`121`	`121`	`}`
`122`	`122`
`123`		`-fn parse_directive_args(self: Parser) -> Array[SourceExpr]!ParserError {`
	`123`	`+fn Parser::parse_directive_args(self: Parser) -> Array[SourceExpr]!ParserError {`
`124`	`124`	`let args: Array[SourceExpr] = []`
`125`	`125`	`while true {`
`126`	`126`	`let expr = self.parse_expr!()`
`@@ -132,7 +132,7 @@ fn parse_directive_args(self: Parser) -> Array[SourceExpr]!ParserError {`
`132`	`132`	`args`
`133`	`133`	`}`
`134`	`134`
`135`		`-fn parse_addressing_mode(`
	`135`	`+fn Parser::parse_addressing_mode(`
`136`	`136`	`self: Parser,`
`137`	`137`	`opcode~: OpCode`
`138`	`138`	`) -> SourceAddressingMode!ParserError {`
`@@ -200,7 +200,7 @@ fn parse_addressing_mode(`
`200`	`200`	`}`
`201`	`201`	`}`
`202`	`202`
`203`		`-fn parse_inst(self: Parser) -> SourceItem!ParserError {`
	`203`	`+fn Parser::parse_inst(self: Parser) -> SourceItem!ParserError {`
`204`	`204`	`let token = self.peek()`
`205`	`205`
`206`	`206`	`match token {`
`@@ -232,7 +232,7 @@ fn parse_inst(self: Parser) -> SourceItem!ParserError {`
`232`	`232`	`}`
`233`	`233`	`}`
`234`	`234`
`235`		`-pub fn parse(self: Parser) -> Array[SourceItem]!ParserError {`
	`235`	`+pub fn Parser::parse(self: Parser) -> Array[SourceItem]!ParserError {`
`236`	`236`	`let insts: Array[SourceItem] = []`
`237`	`237`
`238`	`238`	`while self.index < self.tokens.length() {`
Original file line number	Diff line number	Diff line change
`@@ -147,7 +147,7 @@ fn emit_data_c(self: Emitter, low: @lower.AsmLowering) -> Unit {`
`147`	`147`	`for line in table.lines {`
`148`	`148`	`match line {`
`149`	`149`	`Data(data~, comment~) => {`
`150`		`- let data = String::concat(data.map(show_expr), separator=", ")`
	`150`	`+ let data = @string.concat(data.map(show_expr), separator=", ")`
`151`	`151`
`152`	`152`	`match comment.val {`
`153`	`153`	`"" => self.emit(data + ",")`
`@@ -185,8 +185,8 @@ fn emit_code_h(self: Emitter, low: @lower.AsmLowering) -> Unit {`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`fn rename_label(label: String) -> String {`
`188`		`- if label.ends_with("__sub") {`
`189`		`- label.split("__sub").iter().peek().unwrap()`
	`188`	`+ if label.has_suffix("__sub") {`
	`189`	`+ label.split("__sub").iter().peek().unwrap().to_string()`
`190`	`190`	`} else {`
`191`	`191`	`label`
`192`	`192`	`}`
`@@ -221,15 +221,15 @@ fn show_cond_opcode(op: @parse.OpCode) -> String {`
`221`	`221`	`}`
`222`	`222`	`}`
`223`	`223`
`224`		`-enum Reg { A; X; Y }`
`225`		`-struct Range { min: Int; max: Int }`
	`224`	`+priv enum Reg { A; X; Y }`
	`225`	`+priv struct Range { min: Int; max: Int }`
`226`	`226`
`227`		`-fn op_add(self: Range, other: Range) -> Range {`
	`227`	`+impl Add for Range with op_add(self: Range, other: Range) -> Range {`
`228`	`228`	`{ min: self.min + other.min, max: self.max + other.max }`
`229`	`229`	`}`
`230`	`230`
`231`		`-fn op_sub(self: Range, other: Range) -> Range {`
`232`		`- { min: self.min - other.max, max: self.max - other.min }`
	`231`	`+impl Sub for Range with op_sub(self: Range, other: Range) -> Range {`
	`232`	`+ { min: self.min - other.min, max: self.max - other.max }`
`233`	`233`	`}`
`234`	`234`
`235`	`235`	`fn compute_expr_range(expr: @lower.TypedExpr, low: @lower.AsmLowering) -> Range? {`
`@@ -498,12 +498,12 @@ pub(all) struct File {`
`498`	`498`	`}`
`499`	`499`
`500`	`500`	`fn File::read(name~: String, path~: String, is_lib~: Bool = true) -> File!Error {`
`501`		`- let contents = @fs.read_file_to_string!(path~)`
	`501`	`+ let contents = @fs.read_file_to_string!(path)`
`502`	`502`	`{ name, contents, is_lib }`
`503`	`503`	`}`
`504`	`504`
`505`		`-pub fn write(self: File, dir~: String) -> Unit {`
`506`		`- @fs.write_string_to_file(path="\{dir}/\{self.name}", content=self.contents)`
	`505`	`+pub fn File::write(self: File, dir~: String) -> Unit!Error {`
	`506`	`+ @fs.write_string_to_file!("\{dir}/\{self.name}", self.contents)`
`507`	`507`	`}`
`508`	`508`
`509`	`509`	`pub(all) struct Transpiler {`