data-enum.tea

data Point(x Int, y Int)

data Point3(x, y, z)  # optional types

data one(x); data two(y);

enum empty { }

enum op { Plus, Minus }  # one line

enum comma1 {  # no trailing comma
  Times,
  Divide 
}

enum trailing_comma {  
  Times,
  Divide,
}

enum no_comma {  # newlines are commas
  Times
  Divide
}

enum cflow {  
  Break, Continue, Return(status Int)
}

data Token(id Id, span_id Int, val Str)

enum suffix_op {
  Nullary %Token,  # note this is lexer as an Expr_Symbol
  Unary(op_id Id, arg_word Str)
}

data word(parts Array[WordPart])

enum value {
  Str(s Str),
  AssocArray(d Map[Str, Str])
}

#
# Dicts
#

var d1 = {
}
var d2 = {}
var d3 = {name: 'bob'}

var d4 = {
  name: 'bob'}

var d5 = {name: 'bob'
}
var d6 = {name: 'bob',
}

var commas0 = {
  name: 'bob'
  age: 10
}
var commas1 = {
  name: 'bob',
  age: 10
}

var commas2 = {
  name: 'bob',
  age: 10,
}


var lines = {
  # Continuation valid
  name: \
  bob
}


#
# Functions
#


func add(x, y) { return x + y }

func add(x, y) { return x + y
}

func stmt_semicolon(x, y) { var z = 32; return x + y + z }

func stmt_newline(x, y) {
   var d = [42]
   set d[0] = 5
   return x + y + z
}

func empty() { }
func empty2() {
}

func proclike() {
  # NOT allowed
  #echo hi

  # These ARE allowed.  Special case
  echo 'hi'
  echo 'hi';

  echo 'hi' $there;
  echo 'hi' $there "double" ${x};
}

#
# First Class Funtions
#

var x = func(x) { return x + 1 }

var x = func(x) {
  var f = func(y) {
    return x + y
  }
  return f
}


#
# Classes
#

class empty { }

class empty2 {
}

class Lexer {
  func Run() {
    echo
    # TODO: Fix separators
    #echo
  };

  virtual Foo() {
    echo
  }
}

#echo $'hi\n'

class FileReader : Reader {

  var x Int
  var y

  var a Float; var b;

  # TODO: should this be super() ?
  func init(super, x, y) {
    echo
  }

  override Run() {
    var x = f(x)

    set x[1] = 2

    # Another statement
    echo

    f(x)

    1 + 2

    obj.method(); obj.method2()
    3,4
    (5,6)

    # Doesn't work because it's not testlist
    # Python has expr_stmt
    x = 1
  }

}

class OneVar { var a }

# should we allow this?  C++ allows it.
#class OneVar { }

class OneLine { var a; var b }

class OneLine2 { var a; var b; func f(x) { echo; echo } }

# wtf why can I use these terminators, but not Op_Newline?
# oh maybe the word parser does something with it?

# TODO: Also test

import 'frontend/syntax'
import 'bar' as foo

import 'core/util' (log, p_die, foo as bar)

import 'core/util' as myutil (log as mylog)

import 'one'; import 'two'

#echo hi