vcfxb/wright-lang

The wright programming language (WIP)

wright-lang's Issues

Binary Expression Parser Test Cases

Need to make test cases for all binary operators

Function Definition Parser

Type Definition Parser

`self` expression

Tracking issue for adding the self expression to wright

Match Expression Parser

Parser and Grammar Modules

Finishing the grammar in the the RustPEG file, and writing the parser and parser error structs

WebAssembly

Does the compiler run on WebAssembly (wasm)? Is such feature planned?

Replace `# Comment` style with `// Comment` style.

Trait Definition Parser

Statements

see https://doc.rust-lang.org/stable/reference/statements.html for a bit of reference

AstEq trait

Tracking issue for AstEq trait that compares AST nodes but ignores fragments.

Conditional Expression parser

Conditional expression parser tracking issue.

Syntax should be along the lines of

"if", expr, block, ("else", "if", expr, block)*, ["else", block] 

Pattern Matching Grammar Stuff

https://doc.rust-lang.org/reference/patterns.html

Class Definition Parser

Targets

This is pretty far in the future, but I'll leave some platforms I'm considering targeting here, to look back at for reference later:

• C
• JVM
• LLVM
• Cretonne (If it still exists.)
• Rust (maybe?)
• MIPS (or some subset)
• Brainfuck (maybe?)
• WASM (maybe?)

Enum Definition Parser

Impl Block Parser

Scoped Name/Identifier

ScopedName ::= (Identifier "::")+ Identifier

Interpreter Module

Finishing up the interpreter module and writing unit tests.

Stack_VM Implementation

An implementation of a backend through the Stack VM crate

Block Parser

Block ::= "{" [[Expression [";"]] "}"

Notes:

• Blocks do not need an expression list because the semicolon ; is a binary operator.
• The unit value (of the type void) might be expressed as {}.

Treating blocks as expressions that return the value of Expression poses a parsing question: should blocks be valid anywhere an expression is? Examples include

3 + { "hello"; 4 }
func(3, { 2; 1 })

In this case, if ; keeps being an operator, blocks have the same grouping properties as parentheses ().

3 + ("hello"; 4)
func(3, (2; 1))

Should parenthesized expressions also be considered blocks by the grammar?

If let expression parser

Switch from CodeMap to CodeSpan crate

see the crate page for more info

We are switching to codespan over codemap because it is simply more up to date compared to Rust's libsyntax.

The goal (of course) is to convert all the way to using Rust's libsyntax directly. (however that's not currently possible as it is a nightly-only API right now)

Declassify underscore as an expression

Should the underscore really be an expression?

Function Call Expression

This is the tracking issue for the function call expression (func(args))

Error module

Finishing up the error module and writing unit tests.

JVM Implementation

Implementing a Java Virtual Machine in rust to target with wright

Wright Expression Precedence

Here is a list of applicable Wright expressions with in suggested precedence order.

{
  a::b; // scope resolution
  a.b; // member access
  a..b; // half open range
  a * b / c % d // multiplication/division/remainder
  a + b - c; // addition/subtraction
  a & b; // bitwise and
  a ^ b; // bitwise/logical xor
  a | b; // bitwise or
  a && b; // logical and
  a || b; // logical or
  a < b > c <= d >= e; // comparison
  a == b != c; // equality
  a = b; // assign
  let a = b; // variable creation and jump expressions (e.g. return)
}

This order follows the precedence order in C-like languages, with the additions of variable creation and jump expressions binding at the lowest precedence.

Expressions like { a } and if a { b } else { c } don't need precedence because they do not expose a bare expression at the head or the tail.

The Semicolon Operator and Expression Categories

Currently, the semicolon ; (used to sequence expressions) is a binary operator. However, in some cases, treating ; this way results in weird-looking code. For example,

func(1, 2; 3, 4)

would be equivalent to

func(1, 3, 4)

As well, this creates ambiguity with the hypothetical variable declaration

"let" Identifier "=" Expression

If Expression is a semicolon-expression.

let x = 5; 3
(let x = 5); 3
let x = (5; 3)

Some of the weirdness could be solved by having different categories of expressions for each of these cases, e.g. NonSemicolonExpression, ExpressionOrVariableDecl.

Struct Definition Parser

Binary expression parser

tracking issue for #8

Union Definition Parse

Multiline comments

Once #18 is merged we will need to add on to and modify it to also work for multiline comments. This is the tracking issue for that.

Type System

Tracking issue for the wright type system and type parsers