Introduction

This is a general overview of the compiler

Grammar

A program is composed of a list of items

Paths

A path is a way of refering to named items.

Example

mod utils {
    fn sum(a: i32, b: i32) -> i32 {
        a + b
    }
}

fn foo() -> i32 { utils::sum(1, 2) }

let a: i32;
    
fn main() {
    let a: i32 = 1;     // Local variable
    self::a = foo();    // Access the 'a' variable from the module

}

In the example above we have 4 paths

• Inside sum. Both a and b are paths.
• utils::sum is a path composed of two segments: utils and sum
• self::a is a path that refers to “the item a inside the current module”

Items

Use Items

use items allow to bring other items into scope.

Example

mod utils {
    fn max(a: i32, b: i32) -> i32 {
        if a > b { a } else { b }
    }

    fn abs(a: i32) -> i32 {
        if a > 0 { a } else { a * -1 }
    }
}

use utils::max;
use utils as very_util;

fn main() {
    let a: i32 = max(1, 2);

    let b: i32 = very_util::abs(-3);
}

Modules

A module is a named item that encloses a set items

Example

mod lib {

  mod math {
      fn sum(a: i32, b: i32) -> i32 { a + b }
  }

  mod math_u16 {
    fn sum(a: u16, b: u16) -> u16 { a + b }
  }

  mod person {
      struct Person {
          age: u16,
          name: &char,
      }

      fn is_old(p: &Person) -> bool {
          (*p).age >= 70
      }
  }

}

Structs

Functions

Variables

Expressions

Expressions are the main syntactical construction of the language. They represent an operation that yields a value.

Block Expressions

A BlockExpr is a block that evaluates to an expression. Like any kind of block, it contains a list of statements, and an optional tail expression.

Literal Expressions

If Expressions

An if expression evaluates it’s conditional expression. If it’s true, evaluates it’s then block If it’s false, evaluates it’s else block

An if expression -unlike the if statement- MUST have both a then and an else blocks.

Operators

Arithmetic expressions

Logical Expressions

(De)Reference expressions

Access Expressions

Field Access

Array Access

Tuple Access

Call Expressions

Statements

Types

Example

let a: i32;

struct Person {
    age: u16,
    name: &char,
}

let people: [Person, 12];

Abstract Syntax Tree

The AST is a syntactical representation of a program. It is the output of the parser.

This AST doesn’t have any semantic information. For example, it doesn’t know the different types of binary operations (arithmetic, logical, etc.). It just sees <OPERAND> <OPERATOR> <OPERAND>.

We try to presserve all the syntactic information of the program (semicolons, parenthesis, etc.), and we don’t make up things that aren’t there.

For example, see ItemKind::Function. Its return type is an Option, beacuse this program is syntactically correct:

fn foo() { }

but this one is also correct:

fn foo() -> int { ... }

Another example:

a + ( (b) * 4 )

There are a LOT of unnecesary parenthesis here. It’s nice to have the AST preserve this information so we can, for example, check unnecesary parenthesis.

Later, we’ll lower this AST to the HIR, which will strip unnecesary syntactical information. It’ll also remove parenthesis, since their only job is to explicit the precedence of operations, and they become useless after building the AST.

HIR

The Hir (Higher Intermediate Representation) is the result of lowering the AST