Syntax: bool literals

nois.bnf

@@ -56,6 +56,8 @@ statement             ::= var-def | fn-def | trait-def | impl-def | type-def | r
                       | CHAR
                       | INT
                       | FLOAT
+                      | TRUE
+                      | FALSE
                       | identifier
                       ;
     infix-op          ::= add-op | sub-op | mult-op | div-op | exp-op | mod-op | access-op | eq-op | ne-op

src/ast/index.ts

@@ -29,7 +29,7 @@ export const astExprKinds = <const>[
 
 export const astDefKinds = <const>['var-def', 'fn-def', 'trait-def', 'impl-def', 'type-def', 'field-def']
 
-export const astLiteralKinds = <const>['string-literal', 'char-literal', 'int-literal', 'float-literal']
+export const astLiteralKinds = <const>['string-literal', 'char-literal', 'int-literal', 'float-literal', 'bool-literal']
 
 export const astPrefixOpKinds = <const>['neg-op', 'not-op', 'spread-op']
 

src/ast/operand.ts

@@ -21,6 +21,7 @@ export type Operand =
     | CharLiteral
     | IntLiteral
     | FloatLiteral
+    | BoolLiteral
     | Identifier
 
 export const buildOperand = (node: ParseNode): Operand => {
@@ -50,6 +51,8 @@ export const buildOperand = (node: ParseNode): Operand => {
             return buildIntLiteral(n)
         case 'float':
             return buildFloatLiteral(n)
+        case 'bool':
+            return buildBoolLiteral(n)
         case 'identifier':
             return buildIdentifier(n)
     }
@@ -198,6 +201,14 @@ export const buildFloatLiteral = (node: ParseNode): FloatLiteral => {
     return { kind: 'float-literal', parseNode: node, value: (<LexerToken>node).value }
 }
 
+export interface BoolLiteral extends AstNode<'bool-literal'>, Partial<Typed> {
+    value: string
+}
+
+export const buildBoolLiteral = (node: ParseNode): BoolLiteral => {
+    return { kind: 'bool-literal', parseNode: node, value: (<LexerToken>node).value }
+}
+
 export interface Identifier extends AstNode<'identifier'>, Partial<Typed> {
     scope: Name[]
     name: Name

src/lexer/lexer.ts

@@ -48,7 +48,7 @@ export const lexerKeywordKinds = <const>[
     'pub-keyword'
 ]
 
-export const lexerDynamicKinds = <const>['name', 'string', 'char', 'int', 'float']
+export const lexerDynamicKinds = <const>['name', 'string', 'char', 'int', 'float', 'bool']
 
 const lexerParseIndependentKinds = <const>['comment']
 
@@ -117,6 +117,7 @@ export const lexerKeywordMap: Map<TokenKind, string> = new Map([
     ['at', '@']
 ])
 
+const boolRegex = /^(true|false)/
 const floatRegex = /^((\d+(\.\d*)?e[+-]?\d+)|(\d+\.\d*)|(\d*\.\d+))/
 const escapeCharReg = /(\\[btnvfr\\'"])/
 const unicodeCharReg = /(\\u{[0-9a-fA-F]{1,4}})/
@@ -159,6 +160,7 @@ export const tokenize = (code: string): LexerToken[] => {
         }
 
         const fns = [
+            parseBool,
             parseFloat,
             parseInt,
             parseComment,
@@ -247,6 +249,18 @@ const parseName = (chars: string[], tokens: LexerToken[], pos: { pos: number }):
     return false
 }
 
+const parseBool = (chars: string[], tokens: LexerToken[], pos: { pos: number }): boolean => {
+    const leftCode = chars.slice(pos.pos).join('')
+    const match = leftCode.match(boolRegex)
+    if (!match) return false
+
+    const bool = match[0]
+    const start = pos.pos
+    pos.pos += bool.length
+    tokens.push(createToken('bool', bool, pos, start))
+    return true
+}
+
 const parseFloat = (chars: string[], tokens: LexerToken[], pos: { pos: number }): boolean => {
     if (!isNumeric(chars[pos.pos]) && chars[pos.pos] !== '.') return false
     const leftCode = chars.slice(pos.pos).join('')

src/parser/fns/expr.ts

@@ -44,10 +44,10 @@ export const parseSubExpr = (parser: Parser): void => {
 
 /**
  * operand ::= if-expr | match-expr | closure-expr | O-PAREN expr C-PAREN | list-expr | STRING | CHAR | INT | FLOAT
- * | identifier | type
+ * TRUE | FALSE | identifier | type
  */
 export const parseOperand = (parser: Parser): void => {
-    const dynamicTokens: TokenKind[] = ['string', 'char', 'int', 'float']
+    const dynamicTokens: TokenKind[] = ['string', 'char', 'int', 'float', 'bool']
 
     const mark = parser.open()
     if (parser.at('if-keyword') && parser.nth(1) === 'let-keyword') {

src/parser/fns/index.ts

@@ -36,6 +36,7 @@ export const exprFirstTokens: TokenKind[] = [
     'match-keyword',
     'int',
     'float',
+    'bool',
     'string',
     'o-paren',
     'o-bracket',

src/semantic/expr.ts

@@ -119,6 +119,13 @@ export const checkOperand = (operand: Operand, ctx: Context): void => {
                 typeArgs: []
             }
             break
+        case 'bool-literal':
+            operand.type = {
+                kind: 'vid-type',
+                identifier: vidFromString('std::bool::Bool'),
+                typeArgs: []
+            }
+            break
         case 'identifier':
             checkIdentifier(operand, ctx)
             if (operand.type!.kind === 'unknown-type') {

src/std/bool.no

@@ -5,10 +5,6 @@ pub type Bool {
     False
 }
 
-pub let true: Bool = Bool::True()
-
-pub let false: Bool = Bool::False()
-
 impl Bool {
     pub fn and(self, other: Self): Self {
         andBool(self, other)

src/std/prelude.no

@@ -6,8 +6,7 @@ pub use std::{
     int::Int,
     string::String,
     char::Char,
-    // TODO: bool literals
-    bool::{Bool, true, false},
+    bool::Bool,
     eq::Eq,
     ord::{Ordering, Ord},
     iter::{Iterable, Iter, Collector},