aa
Public Member Functions | Static Package Functions | Static Private Member Functions | Private Attributes | Static Private Attributes | List of all members
com.cliffc.aa.TestParse Class Reference
Collaboration diagram for com.cliffc.aa.TestParse:
[legend]

Public Member Functions

void testParse ()
 
void testParse00 ()
 
void testParse01 ()
 
void testParse01a ()
 
void testParse02 ()
 
void testParse03 ()
 
void testParse04 ()
 
void testParse05 ()
 
void testParse06 ()
 
void testParse07 ()
 
void testParse08 ()
 
void testParse09 ()
 
void testParse10 ()
 
void testParse11 ()
 
void testParse12 ()
 
void testParse13 ()
 
void testParse14 ()
 
void testParse15 ()
 

Static Package Functions

static void testerr (String program, String err, int cur_off)
 

Static Private Member Functions

static TypeEnv run (String program)
 
static String strip_alias_numbers (String err)
 
static void test (String program, Function< Integer, Type > expected)
 
static void test (String program, Type expected)
 
static void test_isa (String program, Type expected)
 
static void test_name (String program, Type... args)
 
static void test_obj (String program, TypeObj expected)
 
static void test_obj_isa (String program, TypeObj expected)
 
static void test_prim (String program, String prim)
 
static void test_ptr (String program, Function< Integer, Type > expected)
 
static void test_ptr (String program, String expected)
 
static void test_ptr0 (String program, Function< Integer, Type > expected)
 
static void test_struct (String program, TypeStruct expected)
 
static void testary (String program, String err, int cur_off)
 
static void testerr (String program, String err, String cursor)
 

Private Attributes

final String DO ="do={pred->{body->!pred()?^;body(); do pred body}};"
 
final String FORELSE ="for={pred->{body->!pred()?^;(tmp=body())?^tmp; for pred body}};"
 

Static Private Attributes

static final BitsFun TEST_FUNBITS = BitsFun.make0(46)
 

Detailed Description

Definition at line 15 of file TestParse.java.

Member Function Documentation

◆ run()

static TypeEnv com.cliffc.aa.TestParse.run ( String  program)
staticprivate

Definition at line 839 of file TestParse.java.

839  {
840  TypeEnv te = Exec.open(Env.file_scope(Env.top_scope()),"args",program);
841  if( te._errs != null ) System.err.println(te._errs.toString());
842  assertNull(te._errs);
843  return te;
844  }

References com.cliffc.aa.TypeEnv._errs, com.cliffc.aa.Env.file_scope(), com.cliffc.aa.Exec.open(), and com.cliffc.aa.Env.top_scope().

Referenced by com.cliffc.aa.TestParse.test(), com.cliffc.aa.TestParse.test_isa(), com.cliffc.aa.TestParse.test_name(), com.cliffc.aa.TestParse.test_obj(), com.cliffc.aa.TestParse.test_obj_isa(), com.cliffc.aa.TestParse.test_ptr(), com.cliffc.aa.TestParse.test_ptr0(), and com.cliffc.aa.TestParse.test_struct().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ strip_alias_numbers()

static String com.cliffc.aa.TestParse.strip_alias_numbers ( String  err)
staticprivate

Definition at line 939 of file TestParse.java.

939  {
940  // Remove alias#s from the result string: *[123]@{x=1,y=2} ==> *[$]@{x=1,y=2}
941  // \\ Must use two \\ because of String escaping for every 1 in the regex.
942  // Thus replacing: \[[,0-9]* with: \[\$
943  // Regex breakdown:
944  // \\[ prevents using '[' as the start of a regex character class
945  // [,0-9] matches digits and commas
946  // * matches all the digits and commas
947  // \\[ Replacement [ because the first one got matched and replaced.
948  // \\$ Prevent $ being interpreted as a regex group start
949  return err.replaceAll("\\[[,0-9]*", "\\[\\$");
950  }

Referenced by com.cliffc.aa.TestParse.test_ptr(), and com.cliffc.aa.TestParse.testerr().

Here is the caller graph for this function:

◆ test() [1/2]

static void com.cliffc.aa.TestParse.test ( String  program,
Function< Integer, Type >  expected 
)
staticprivate

Definition at line 916 of file TestParse.java.

916  {
917  try( TypeEnv te = run(program) ) {
918  Type t_expected = expected.apply(-99); // unimpl
919  assertEquals(t_expected,te._t);
920  }
921  }

References com.cliffc.aa.TestParse.run().

Here is the call graph for this function:

◆ test() [2/2]

static void com.cliffc.aa.TestParse.test ( String  program,
Type  expected 
)
staticprivate

Definition at line 846 of file TestParse.java.

846  {
847  try( TypeEnv te = run(program) ) {
848  assertEquals(expected,te._t);
849  }
850  }

References com.cliffc.aa.TestParse.run().

Referenced by com.cliffc.aa.TestParse.testParse(), com.cliffc.aa.TestParse.testParse00(), com.cliffc.aa.TestParse.testParse01(), com.cliffc.aa.TestParse.testParse01a(), com.cliffc.aa.TestParse.testParse02(), com.cliffc.aa.TestParse.testParse03(), com.cliffc.aa.TestParse.testParse04(), com.cliffc.aa.TestParse.testParse05(), com.cliffc.aa.TestParse.testParse06(), com.cliffc.aa.TestParse.testParse07(), com.cliffc.aa.TestParse.testParse09(), com.cliffc.aa.TestParse.testParse10(), com.cliffc.aa.TestParse.testParse11(), com.cliffc.aa.TestParse.testParse12(), com.cliffc.aa.TestParse.testParse13(), com.cliffc.aa.TestParse.testParse14(), and com.cliffc.aa.TestParse.testParse15().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ test_isa()

static void com.cliffc.aa.TestParse.test_isa ( String  program,
Type  expected 
)
staticprivate

Definition at line 922 of file TestParse.java.

922  {
923  try( TypeEnv te = run(program) ) {
924  Type actual = te._tmem.sharptr(te._t);
925  assertTrue(actual.isa(expected));
926  }
927  }

References com.cliffc.aa.type.Type< T extends Type< T >.isa(), com.cliffc.aa.TestParse.run(), and com.cliffc.aa.type.Type< T extends Type< T >.sharptr().

Referenced by com.cliffc.aa.TestParse.testParse(), com.cliffc.aa.TestParse.testParse02(), com.cliffc.aa.TestParse.testParse06(), com.cliffc.aa.TestParse.testParse07(), com.cliffc.aa.TestParse.testParse08(), and com.cliffc.aa.TestParse.testParse15().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ test_name()

static void com.cliffc.aa.TestParse.test_name ( String  program,
Type...  args 
)
staticprivate

Definition at line 860 of file TestParse.java.

860  {
861  try( TypeEnv te = run(program) ) {
862  assertTrue(te._t instanceof TypeFunPtr);
863  TypeFunPtr actual = (TypeFunPtr)te._t;
864  TypeFunPtr expected = TypeFunPtr.make(actual.fidxs(),ARG_IDX+1, TypeMemPtr.NO_DISP);
865  assertEquals(expected,actual);
866  }
867  }

References com.cliffc.aa.type.TypeFunPtr.fidxs(), com.cliffc.aa.type.TypeFunPtr.make(), com.cliffc.aa.type.TypeMemPtr.NO_DISP, and com.cliffc.aa.TestParse.run().

Referenced by com.cliffc.aa.TestParse.testParse03().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ test_obj()

static void com.cliffc.aa.TestParse.test_obj ( String  program,
TypeObj  expected 
)
staticprivate

Definition at line 886 of file TestParse.java.

886  {
887  try( TypeEnv te = run(program) ) {
888  assertTrue(te._t instanceof TypeMemPtr);
889  int alias = ((TypeMemPtr)te._t).getbit(); // internally asserts only 1 bit set
890  TypeObj actual = te._tmem.ld((TypeMemPtr)te._t);
891  assertEquals(expected,actual);
892  }
893  }

References com.cliffc.aa.TestParse.run().

Referenced by com.cliffc.aa.TestParse.testParse(), com.cliffc.aa.TestParse.testParse00(), com.cliffc.aa.TestParse.testParse01a(), com.cliffc.aa.TestParse.testParse02(), com.cliffc.aa.TestParse.testParse03(), com.cliffc.aa.TestParse.testParse04(), com.cliffc.aa.TestParse.testParse05(), com.cliffc.aa.TestParse.testParse09(), and com.cliffc.aa.TestParse.testParse14().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ test_obj_isa()

static void com.cliffc.aa.TestParse.test_obj_isa ( String  program,
TypeObj  expected 
)
staticprivate

Definition at line 901 of file TestParse.java.

901  {
902  try( TypeEnv te = run(program) ) {
903  int alias = ((TypeMemPtr)te._t)._aliases.strip_nil().getbit(); // internally asserts only 1 bit set
904  TypeObj actual = te._tmem.sharpen((TypeMemPtr)te._t)._obj;
905  assertTrue(actual.isa(expected));
906  }
907  }

References com.cliffc.aa.type.Type< T extends Type< T >.isa(), and com.cliffc.aa.TestParse.run().

Referenced by com.cliffc.aa.TestParse.testParse04(), com.cliffc.aa.TestParse.testParse07(), and com.cliffc.aa.TestParse.testParse10().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ test_prim()

static void com.cliffc.aa.TestParse.test_prim ( String  program,
String  prim 
)
staticprivate

Definition at line 851 of file TestParse.java.

851  {
852  Env top = Env.top_scope();
853  Type expected = top.lookup_valtype(prim);
854  try( TypeEnv te = Exec.open(Env.file_scope(top),"args",program) ) {
855  if( te._errs != null ) System.err.println(te._errs.toString());
856  assertNull(te._errs);
857  assertEquals(expected,te._t);
858  }
859  }

References com.cliffc.aa.Env.file_scope(), com.cliffc.aa.Env.lookup_valtype(), com.cliffc.aa.Exec.open(), and com.cliffc.aa.Env.top_scope().

Referenced by com.cliffc.aa.TestParse.testParse00(), and com.cliffc.aa.TestParse.testParse15().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ test_ptr() [1/2]

static void com.cliffc.aa.TestParse.test_ptr ( String  program,
Function< Integer, Type >  expected 
)
staticprivate

Definition at line 868 of file TestParse.java.

868  {
869  try( TypeEnv te = run(program) ) {
870  TypeMemPtr actual = te._tmem.sharpen((TypeMemPtr)te._t);
871  int alias = actual.getbit(); // internally asserts only 1 bit set
872  Type t_expected = expected.apply(alias);
873  assertEquals(t_expected,actual);
874  }
875  }

References com.cliffc.aa.type.TypeMemPtr.getbit(), and com.cliffc.aa.TestParse.run().

Referenced by com.cliffc.aa.TestParse.testParse(), com.cliffc.aa.TestParse.testParse03(), com.cliffc.aa.TestParse.testParse04(), com.cliffc.aa.TestParse.testParse06(), com.cliffc.aa.TestParse.testParse07(), com.cliffc.aa.TestParse.testParse08(), com.cliffc.aa.TestParse.testParse10(), com.cliffc.aa.TestParse.testParse14(), and com.cliffc.aa.TestParse.testParse15().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ test_ptr() [2/2]

static void com.cliffc.aa.TestParse.test_ptr ( String  program,
String  expected 
)
staticprivate

Definition at line 908 of file TestParse.java.

908  {
909  try( TypeEnv te = run(program) ) {
910  assertTrue(te._t instanceof TypeMemPtr);
911  TypeObj to = te._tmem.ld((TypeMemPtr)te._t); // Peek thru pointer
912  SB sb = to.str(new SB(),new VBitSet(),te._tmem,false); // Print what we see, with memory
913  assertEquals(expected,strip_alias_numbers(sb.toString()));
914  }
915  }

References com.cliffc.aa.TestParse.run(), com.cliffc.aa.type.TypeObj< O extends TypeObj< O >.str(), com.cliffc.aa.TestParse.strip_alias_numbers(), and com.cliffc.aa.util.SB.toString().

Here is the call graph for this function:

◆ test_ptr0()

static void com.cliffc.aa.TestParse.test_ptr0 ( String  program,
Function< Integer, Type >  expected 
)
staticprivate

Definition at line 876 of file TestParse.java.

876  {
877  try( TypeEnv te = run(program) ) {
878  TypeMemPtr tmp = te._tmem.sharpen((TypeMemPtr)te._t);
879  BitsAlias bits = tmp._aliases;
880  assertTrue(bits.test(0));
881  int alias = bits.strip_nil().getbit(); // internally asserts only 1 bit set
882  Type t_expected = expected.apply(alias);
883  assertEquals(t_expected,tmp);
884  }
885  }

References com.cliffc.aa.type.TypeMemPtr._aliases, com.cliffc.aa.TestParse.run(), com.cliffc.aa.type.Bits< B extends Bits< B >.strip_nil(), and com.cliffc.aa.type.Bits< B extends Bits< B >.test().

Referenced by com.cliffc.aa.TestParse.testParse01(), and com.cliffc.aa.TestParse.testParse05().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ test_struct()

static void com.cliffc.aa.TestParse.test_struct ( String  program,
TypeStruct  expected 
)
staticprivate

Definition at line 894 of file TestParse.java.

894  {
895  try( TypeEnv te = run(program) ) {
896  TypeStruct actual = (TypeStruct)te._tmem.ld((TypeMemPtr)te._t);
897  actual = actual.set_fld(0,TypeMemPtr.NO_DISP,Access.Final);
898  assertEquals(expected,actual);
899  }
900  }

References com.cliffc.aa.type.TypeFld.Access.Final, com.cliffc.aa.type.TypeMemPtr.NO_DISP, com.cliffc.aa.TestParse.run(), and com.cliffc.aa.type.TypeStruct.set_fld().

Referenced by com.cliffc.aa.TestParse.testParse07(), and com.cliffc.aa.TestParse.testParse15().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ testary()

static void com.cliffc.aa.TestParse.testary ( String  program,
String  err,
int  cur_off 
)
staticprivate

Definition at line 951 of file TestParse.java.

951  {
952  TypeEnv te = Exec.go(Env.file_scope(Env.top_scope()),"args",program);
953  assertTrue(te._errs != null && te._errs.size()>=1);
954  String cursor = new String(new char[cur_off]).replace('\0', ' ');
955  String err2 = new SB().p("args:1:").p(err).nl().p(program).nl().p(cursor).p('^').nl().toString();
956  assertEquals(err2,te._errs.get(0).toString());
957  }

References com.cliffc.aa.TypeEnv._errs, com.cliffc.aa.Env.file_scope(), com.cliffc.aa.Exec.go(), com.cliffc.aa.util.SB.nl(), com.cliffc.aa.util.SB.p(), com.cliffc.aa.Env.top_scope(), and com.cliffc.aa.util.SB.toString().

Referenced by com.cliffc.aa.TestParse.testParse14().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ testerr() [1/2]

static void com.cliffc.aa.TestParse.testerr ( String  program,
String  err,
int  cur_off 
)
staticpackage

Definition at line 932 of file TestParse.java.

932  {
933  TypeEnv te = Exec.go(Env.file_scope(Env.top_scope()),"args",program);
934  assertTrue(te._errs != null && te._errs.size()>=1);
935  String cursor = new String(new char[cur_off]).replace('\0', ' ');
936  String err2 = new SB().p("args:1:").p(err).nl().p(program).nl().p(cursor).p('^').nl().toString();
937  assertEquals(err2,strip_alias_numbers(te._errs.get(0).toString()));
938  }

References com.cliffc.aa.TypeEnv._errs, com.cliffc.aa.Env.file_scope(), com.cliffc.aa.Exec.go(), com.cliffc.aa.util.SB.nl(), com.cliffc.aa.util.SB.p(), com.cliffc.aa.TestParse.strip_alias_numbers(), com.cliffc.aa.Env.top_scope(), and com.cliffc.aa.util.SB.toString().

Here is the call graph for this function:

◆ testerr() [2/2]

static void com.cliffc.aa.TestParse.testerr ( String  program,
String  err,
String  cursor 
)
staticprivate

Definition at line 928 of file TestParse.java.

928  {
929  System.out.println("fix test, cur_off="+cursor.length());
930  fail();
931  }

Referenced by com.cliffc.aa.TestParse.testParse(), com.cliffc.aa.TestParse.testParse00(), com.cliffc.aa.TestParse.testParse01(), com.cliffc.aa.TestParse.testParse01a(), com.cliffc.aa.TestParse.testParse02(), com.cliffc.aa.TestParse.testParse03(), com.cliffc.aa.TestParse.testParse04(), com.cliffc.aa.TestParse.testParse05(), com.cliffc.aa.TestParse.testParse08(), com.cliffc.aa.TestParse.testParse09(), com.cliffc.aa.TestParse.testParse10(), and com.cliffc.aa.TestParse.testParse15().

Here is the caller graph for this function:

◆ testParse()

void com.cliffc.aa.TestParse.testParse ( )

Definition at line 19 of file TestParse.java.

19  {
20  // TODO:
21  // TEST for merging str:[7+43+44] and another concrete fcn, such as {&}.
22  // The Meet loses precision to fast. This is a typing bug.
23 
24  // fails, str.hash, str.eq is missing.
25  // needs a class for primitives which includes things like hash & eq & toString.
26  //test("tab = [7];\n" +
27  // "put = { key val ->\n" +
28  // " idx = key.hash() % #tab;\n" +
29  // " entry = tab[idx];\n" +
30  // " entry && key.eq(entry.key) ? (oldval=entry.val; entry.val:=val; ^oldval);\n" +
31  // " 0\n" +
32  // "};\n" +
33  // "put(\"Monday\",1);\n",
34  // Type.XNIL);
35 
36  // A collection of tests which like to fail easily
37  test("-1", TypeInt.con( -1));
38  test("{5}()", TypeInt.con(5)); // No args nor -> required; this is simply a function returning 5, being executed
39  testerr("x=1+y","Unknown ref 'y'",4);
40  test_obj("str(3.14)", TypeStr.con("3.14"));
41  test("math_rand(1)?x=4:x=3;x", TypeInt.NINT8); // x defined on both arms, so available after
42  test_ptr("x=@{n:=1;v:=2}; x.n := 3; x", "@{n:=3; v:=2}");
43  test("x=3; mul2={x -> x*2}; mul2(2.1)", TypeFlt.con(2.1*2.0)); // must inline to resolve overload {*}:Flt with I->F conversion
44  testerr("sq={x -> x*x}; sq(\"abc\")", "*\"abc\" is none of (flt64,int64)",9);
45  test("fun:{int str -> int}={x y -> x+2}; fun(2,3)", TypeInt.con(4));
46  testerr("math_rand(1)?x=2: 3 ;y=x+2;y", "'x' not defined on false arm of trinary",20);
47  testerr("{+}(1,2,3)", "Passing 3 arguments to {+} which takes 2 arguments",3);
48  test_isa("{x y -> x+y}", TypeFunPtr.make(BitsFun.make0(46),3, TypeMemPtr.NO_DISP)); // {Scalar Scalar -> Scalar}
49  testerr("dist={p->p.x*p.x+p.y*p.y}; dist(@{x=1})", "Unknown field '.y' in @{x=1}",19);
50  testerr("Point=:@{x;y}; Point((0,1))", "*(0, 1) is not a *Point:@{x:=; y:=}",21);
51  test("x=@{a:=1; b= {a=a+1;b=0}}; x. b(); x.a",TypeInt.con(2));
52  test("x=@{a:=1;noinline_b= {a=a+1;b=0}}; x.noinline_b(); x.a",TypeInt.NINT8);
53 
54  test("f0 = { f x -> x ? f(f0(f,x-1),1) : 0 }; f0({&},2)", Type.XNIL);
55  test("fact = { x -> x <= 1 ? x : x*fact(x-1) }; fact(1)",TypeInt.con(1));
56  test("fact = { x -> x <= 1 ? x : x*fact(x-1) }; fact(3)",TypeInt.con(6));
57  test("is_even = { n -> n ? is_odd(n-1) : 1}; is_odd = {n -> n ? is_even(n-1) : 0}; is_even(99)", TypeInt.BOOL );
58  test("fib = { x -> x <= 1 ? 1 : fib(x-1)+fib(x-2) }; fib(1)",TypeInt.con(1));
59  test("fib = { x -> x <= 1 ? 1 : fib(x-1)+fib(x-2) }; fib(4)",TypeInt.con(5));
60  test("A= :@{n=A?; v=flt}; f={x:A? -> x ? A(f(x.n),x.v*x.v) : 0}; f(A(0,1.2)).v;", TypeFlt.con(1.2*1.2));
61  testerr("fact = { x -> x <= 1 ? x : x*fact(x-1) }; fact(0);(1,);(1,).0;@{x;y];","Expected closing '}' but found ']' instead",63);
62  // id accepts and returns both ints and reference types (arrays).
63  //test_struct("noinline_id = {x->x};(noinline_id(5)&7, #noinline_id([3]))",TypeStruct.make_tuple(Type.XNIL,TypeInt.INT8,TypeInt.con(3)));
64  }

References com.cliffc.aa.type.TypeInt.BOOL, com.cliffc.aa.type.TypeFlt.con(), com.cliffc.aa.type.TypeInt.con(), com.cliffc.aa.type.TypeStr.con(), com.cliffc.aa.type.TypeFunPtr.make(), com.cliffc.aa.type.BitsFun.make0(), com.cliffc.aa.type.TypeInt.NINT8, com.cliffc.aa.type.TypeMemPtr.NO_DISP, com.cliffc.aa.TestParse.test(), com.cliffc.aa.TestParse.test_isa(), com.cliffc.aa.TestParse.test_obj(), com.cliffc.aa.TestParse.test_ptr(), com.cliffc.aa.TestParse.testerr(), and com.cliffc.aa.type.Type< T extends Type< T >.XNIL.

Here is the call graph for this function:

◆ testParse00()

void com.cliffc.aa.TestParse.testParse00 ( )

Definition at line 66 of file TestParse.java.

66  {
67  // Simple int
68  test("1", TypeInt.TRUE);
69  // Unary operator
70  test("-1", TypeInt.con( -1));
71  test("!1", Type.XNIL);
72  // Binary operators
73  test("1+2", TypeInt.con( 3));
74  test("1-2", TypeInt.con( -1));
75  test("1+2*3", TypeInt.con( 7));
76  test("1 < 2", TypeInt.TRUE );
77  test("1 <=2", TypeInt.TRUE );
78  test("1 > 2", TypeInt.FALSE);
79  test("1 >=2", TypeInt.FALSE);
80  test("1 ==2", TypeInt.FALSE);
81  test("1 !=2", TypeInt.TRUE );
82  test("1.2< 2", TypeInt.TRUE );
83  test("1.2<=2", TypeInt.TRUE );
84  test("1.2> 2", TypeInt.FALSE);
85  test("1.2>=2", TypeInt.FALSE);
86  test("1.2==2", TypeInt.FALSE);
87  test("1.2!=2", TypeInt.TRUE );
88 
89  // Binary with precedence check
90  test(" 1+2 * 3+4 *5", TypeInt.con( 27));
91  test("(1+2)*(3+4)*5", TypeInt.con(105));
92  test("1// some comment\n+2", TypeInt.con(3)); // With bad comment
93  test("-1-2*3-4*5", TypeInt.con(-1-(2*3)-(4*5)));
94  test("1&3|1&2", TypeInt.con(1));
95 
96  // Float
97  test("1.2+3.4", TypeFlt.make(0,64,4.6));
98  // Mixed int/float with conversion
99  test("1+2.3", TypeFlt.make(0,64,3.3));
100 
101  // Simple strings
102  test_obj("\"Hello, world\"", TypeStr.con("Hello, world"));
103  test_obj("str(3.14)" , TypeStr.con("3.14"));
104  test_obj("str(3)" , TypeStr.con("3" ));
105  test_obj("str(\"abc\")" , TypeStr.ABC);
106  test("\"abc\"==\"abc\"",TypeInt.TRUE); // Constant strings intern
107 
108 
109  // Variable lookup
110  test("math_pi", TypeFlt.PI);
111  // bare function lookup; returns a union of '+' functions
112  testerr("+", "Syntax error; trailing junk",0);
113  testerr("!", "Syntax error; trailing junk",0);
114  test_prim("{+}", "+");
115  test_prim("{!}", "!"); // uniops are just like normal functions
116  // Function application, traditional paren/comma args
117  test("{+}(1,2)", TypeInt.con( 3));
118  test("{-}(1,2)", TypeInt.con(-1)); // binary version
119  test(" - (1 )", TypeInt.con(-1)); // unary version
120  // error; mismatch arg count
121  testerr("{!}() ", "Passing 0 arguments to {!} which takes 1 arguments",3);
122  testerr("math_pi(1)", "A function is being called, but 3.141592653589793 is not a function",10);
123  testerr("{+}(1,2,3)", "Passing 3 arguments to {+} which takes 2 arguments",3);
124 
125  // Parsed as +(1,(2*3))
126  test("{+}(1, 2 * 3) ", TypeInt.con(7));
127  // Parsed as +( (1+2*3) , (4*5+6) )
128  test("{+}(1 + 2 * 3, 4 * 5 + 6) ", TypeInt.con(33));
129  // Statements
130  test("(1;2 )", TypeInt.con(2));
131  test("(1;2;)", TypeInt.con(2)); // final semicolon is optional
132  test("{+}(1;2 ,3)", TypeInt.con(5)); // statements in arguments
133  test("{+}(1;2;,3)", TypeInt.con(5)); // statements in arguments
134  // Operators squished together
135  test("-1== -1", TypeInt.TRUE);
136  test("0== !!1", TypeInt.FALSE);
137  test("2==-1", TypeInt.FALSE);
138  test("-1== --1", TypeInt.FALSE);
139  test("-1== ---1",TypeInt.TRUE);
140  testerr("-1== --", "Missing term after '=='",5);
141  }

References com.cliffc.aa.type.TypeStr.ABC, com.cliffc.aa.type.TypeInt.con(), com.cliffc.aa.type.TypeStr.con(), com.cliffc.aa.type.TypeInt.FALSE, com.cliffc.aa.type.TypeFlt.make(), com.cliffc.aa.type.TypeFlt.PI, com.cliffc.aa.TestParse.test(), com.cliffc.aa.TestParse.test_obj(), com.cliffc.aa.TestParse.test_prim(), com.cliffc.aa.TestParse.testerr(), com.cliffc.aa.type.TypeInt.TRUE, and com.cliffc.aa.type.Type< T extends Type< T >.XNIL.

Here is the call graph for this function:

◆ testParse01()

void com.cliffc.aa.TestParse.testParse01 ( )

Definition at line 143 of file TestParse.java.

143  {
144  // Syntax for variable assignment
145  test("x=1", TypeInt.TRUE);
146  test("x=y=1", TypeInt.TRUE);
147  testerr("x=y=", "Missing ifex after assignment of 'y'",4);
148  testerr("x=z" , "Unknown ref 'z'",2);
149  testerr("x=1+y","Unknown ref 'y'",4);
150  testerr("x=y; x=y","Unknown ref 'y'",2);
151  test("x=2; y=x+1; x*y", TypeInt.con(6));
152  // Re-use ref immediately after def; parses as: x=(2*3); 1+x+x*x
153  test("1+(x=2*3)+x*x", TypeInt.con(1+6+6*6));
154  testerr("x=(1+(x=2)+x); x", "Cannot re-assign final val 'x'",0);
155  test("x:=1;x++" ,TypeInt.con(1));
156  test("x:=1;x++;x",TypeInt.con(2));
157  test("x:=1;x++ + x--",TypeInt.con(3));
158  test("x++",Type.XNIL);
159  test("x++;x",TypeInt.con(1));
160 
161  // Conditional:
162  test ("0 ? 2 : 3", TypeInt.con(3)); // false
163  test ("2 ? 2 : 3", TypeInt.con(2)); // true
164  test ("math_rand(1)?x=4:x=3;x", TypeInt.NINT8); // x defined on both arms, so available after
165  test ("math_rand(1)?x=2: 3;4", TypeInt.con(4)); // x-defined on 1 side only, but not used thereafter
166  test ("math_rand(1)?(y=2;x=y*y):x=3;x", TypeInt.NINT8); // x defined on both arms, so available after, while y is not
167  testerr("math_rand(1)?x=2: 3 ;x", "'x' not defined on false arm of trinary",20);
168  testerr("math_rand(1)?x=2: 3 ;y=x+2;y", "'x' not defined on false arm of trinary",20);
169  testerr("0 ? x=2 : 3;x", "'x' not defined on false arm of trinary",11);
170  test ("2 ? x=2 : 3;x", TypeInt.con(2)); // off-side is constant-dead, so missing x-assign is ignored
171  test ("2 ? x=2 : y ", TypeInt.con(2)); // off-side is constant-dead, so missing 'y' is ignored
172  testerr("x=1;2?(x=2):(x=3);x", "Cannot re-assign final val 'x'",7);
173  test ("x=1;2? 2 :(x=3);x",TypeInt.con(1)); // Re-assigned allowed & ignored in dead branch
174  test ("math_rand(1)?1:int:2:int",TypeInt.NINT8); // no ambiguity between conditionals and type annotations
175  testerr("math_rand(1)?1: :2:int","missing expr after ':'",16); // missing type
176  testerr("math_rand(1)?1::2:int","missing expr after ':'",15); // missing type
177  testerr("math_rand(1)?1:\"a\"", "Cannot mix GC and non-GC types",18);
178  test ("math_rand(1)?1",TypeInt.BOOL); // Missing optional else defaults to nil
179  test_ptr0("math_rand(1)?\"abc\"", (alias)->TypeMemPtr.make_nil(alias,TypeStr.ABC));
180  test ("x:=0;math_rand(1)?(x:=1);x",TypeInt.BOOL);
181  testerr("a.b.c();","Unknown ref 'a'",0);
182  }

References com.cliffc.aa.type.TypeStr.ABC, com.cliffc.aa.type.TypeInt.BOOL, com.cliffc.aa.type.TypeInt.con(), com.cliffc.aa.type.TypeMemPtr.make_nil(), com.cliffc.aa.type.TypeInt.NINT8, com.cliffc.aa.TestParse.test(), com.cliffc.aa.TestParse.test_ptr0(), com.cliffc.aa.TestParse.testerr(), com.cliffc.aa.type.TypeInt.TRUE, and com.cliffc.aa.type.Type< T extends Type< T >.XNIL.

Here is the call graph for this function:

◆ testParse01a()

void com.cliffc.aa.TestParse.testParse01a ( )

Definition at line 185 of file TestParse.java.

185  {
186  test("0 && 0", Type.XNIL);
187  test("1 && 2", TypeInt.con(2));
188  test("0 && 2", Type.XNIL);
189  test("0 || 0", Type.XNIL);
190  test("0 || 2", TypeInt.con(2));
191  test("1 || 2", TypeInt.con(1));
192  test("0 && 1 || 2 && 3", TypeInt.con(3)); // Precedence
193 
194  test_obj("x:=y:=0; z=x++ && y++;(x,y,z)", // increments x, but it starts zero, so y never increments
195  TypeStruct.make(TypeStruct.tups(TypeInt.con(1),Type.XNIL,Type.XNIL)));
196  test_obj("x:=y:=0; x++ && y++; z=x++ && y++; (x,y,z)", // x++; x++; y++; (2,1,0)
197  TypeStruct.make(TypeStruct.tups(TypeInt.con(2),TypeInt.con(1),Type.XNIL)));
198  test("(x=1) && x+2", TypeInt.con(3)); // Def x in 1st position
199 
200  testerr("1 && (x=2;0) || x+3 && x+4", "'x' not defined prior to the short-circuit",5); // x maybe alive
201  testerr("0 && (x=2;0) || x+3 && x+4", "'x' not defined prior to the short-circuit",5); // x definitely not alive
202  test("math_rand(1) && (x=2;x*x) || 3 && 4", TypeInt.INT8); // local use of x in short-circuit; requires unzip to find 4
203  }

References com.cliffc.aa.type.TypeInt.con(), com.cliffc.aa.type.TypeInt.INT8, com.cliffc.aa.type.TypeStruct.make(), com.cliffc.aa.TestParse.test(), com.cliffc.aa.TestParse.test_obj(), com.cliffc.aa.TestParse.testerr(), com.cliffc.aa.type.TypeStruct.tups(), and com.cliffc.aa.type.Type< T extends Type< T >.XNIL.

Here is the call graph for this function:

◆ testParse02()

void com.cliffc.aa.TestParse.testParse02 ( )

Definition at line 205 of file TestParse.java.

205  {
206  test("{5}()", TypeInt.con(5)); // No args nor -> required; this is simply a function returning 5, being executed
207  // Since call not-taken, post GCP Parms not loaded from _tf, limited to ~Scalar. The
208  // hidden internal call from {&} to the primitive is never inlined (has ~Scalar args)
209  // so 'x&1' never sees the TypeInt return from primitive AND.
210  TypeMemPtr tdisp = TypeMemPtr.make(BitsAlias.make0(12),TypeObj.ISUSED);
211  test_isa("{x -> x&1}", TypeFunPtr.make(TEST_FUNBITS,2,tdisp)); // {Int -> Int}
212 
213  // Anonymous function definition
214  test_isa("{x y -> x+y}", TypeFunPtr.make(TEST_FUNBITS,3,tdisp)); // {Scalar Scalar -> Scalar}
215 
216  // Function execution and result typing
217  test("x=3; andx={y -> x & y}; andx(2)", TypeInt.con(2)); // trivially inlined; capture external variable
218  test("x=3; and2={x -> x & 2}; and2(x)", TypeInt.con(2)); // trivially inlined; shadow external variable
219  testerr("plus2={x -> x+2}; x", "Unknown ref 'x'",18); // Scope exit ends lifetime
220  testerr("fun={x -> }; fun(0)", "Missing function body",10);
221  testerr("fun(2)", "Unknown ref 'fun'", 0);
222  test("mul3={x -> y=3; x*y}; mul3(2)", TypeInt.con(6)); // multiple statements in func body
223  // Needs overload cloning/inlining to resolve {+}
224  test("x=3; addx={y -> x+y}; addx(2)", TypeInt.con(5)); // must inline to resolve overload {+}:Int
225  test("x=3; mul2={x -> x*2}; mul2(2.1)", TypeFlt.con(2.1*2.0)); // must inline to resolve overload {*}:Flt with I->F conversion
226  test("x=3; mul2={x -> x*2}; mul2(2.1)+mul2(x)", TypeFlt.con(2.1*2.0+3*2)); // Mix of types to mul2(), mix of {*} operators
227  test("sq={x -> x*x}; sq 2.1", TypeFlt.con(4.41)); // No () required for single args
228  testerr("sq={x -> x&x}; sq(\"abc\")", "*\"abc\" is not a int64",9);
229  testerr("sq={x -> x*x}; sq(\"abc\")", "*\"abc\" is none of (flt64,int64)",9);
230  testerr("f0 = { f x -> f0(x-1) }; f0({+},2)", "Passing 1 arguments to f0 which takes 2 arguments",16);
231  // Recursive:
232  test("fact = { x -> x <= 1 ? x : x*fact(x-1) }; fact(3)",TypeInt.con(6));
233  test("fib = { x -> x <= 1 ? 1 : fib(x-1)+fib(x-2) }; fib(4)",TypeInt.con(5));
234  test("f0 = { x -> x ? {+}(f0(x-1),1) : 0 }; f0(2)", TypeInt.con(2));
235  testerr("fact = { x -> x <= 1 ? x : x*fact(x-1) }; fact()","Passing 0 arguments to fact which takes 1 arguments",46);
236  test_obj("fact = { x -> x <= 1 ? x : x*fact(x-1) }; (fact(0),fact(1),fact(2))",
237  TypeStruct.make(TypeStruct.tups(Type.XNIL,TypeInt.con(1),TypeInt.con(2))));
238 
239  // Co-recursion requires parallel assignment & type inference across a lexical scope
240  test("is_even = { n -> n ? is_odd(n-1) : 1}; is_odd = {n -> n ? is_even(n-1) : 0}; is_even(4)", TypeInt.con(1) );
241  test("is_even = { n -> n ? is_odd(n-1) : 1}; is_odd = {n -> n ? is_even(n-1) : 0}; is_even(99)", TypeInt.BOOL );
242 
243  // This test merges 2 TypeFunPtrs in a Phi, and then fails to resolve.
244  testerr("(math_rand(1) ? {+} : {*})(2,3)","Unable to resolve call",26); // either 2+3 or 2*3, or {5,6} which is INT8.
245  }

References com.cliffc.aa.type.TypeInt.BOOL, com.cliffc.aa.type.TypeFlt.con(), com.cliffc.aa.type.TypeInt.con(), com.cliffc.aa.type.TypeObj< O extends TypeObj< O >.ISUSED, com.cliffc.aa.type.TypeMemPtr.make(), com.cliffc.aa.type.TypeFunPtr.make(), com.cliffc.aa.type.TypeStruct.make(), com.cliffc.aa.type.BitsAlias.make0(), com.cliffc.aa.TestParse.test(), com.cliffc.aa.TestParse.TEST_FUNBITS, com.cliffc.aa.TestParse.test_isa(), com.cliffc.aa.TestParse.test_obj(), com.cliffc.aa.TestParse.testerr(), com.cliffc.aa.type.TypeStruct.tups(), and com.cliffc.aa.type.Type< T extends Type< T >.XNIL.

Here is the call graph for this function:

◆ testParse03()

void com.cliffc.aa.TestParse.testParse03 ( )

Definition at line 247 of file TestParse.java.

247  {
248  // Type annotations
249  test("-1:int", TypeInt.con( -1));
250  test("(1+2.3):flt", TypeFlt.make(0,64,3.3));
251  test("x:int = 1", TypeInt.TRUE);
252  test("x:flt = 1", TypeInt.TRUE); // casts for free to a float
253  testerr("x:flt32 = 123456789", "123456789 is not a flt32",1);
254  testerr("1:","Syntax error; trailing junk",1); // missing type
255  testerr("2:x", "Syntax error; trailing junk", 1);
256  testerr("(2:)", "Syntax error; trailing junk", 2);
257 
258  test (" -1 :int1", TypeInt.con(-1));
259  testerr("(-1):int1", "-1 is not a int1",4);
260  testerr("\"abc\":int", "*\"abc\" is not a int64",5);
261  testerr("1:str", "1 is not a *str",1);
262 
263  test ("{x:int -> x*2}(1)", TypeInt.con(2)); // Types on parms
264  testerr("{x:str -> x}(1)", "1 is not a *str", 13);
265 
266  // Type annotations on dead args are ignored
267  test ("fun:{int str -> int}={x y -> x+2}; fun(2,3)", TypeInt.con(4));
268  testerr("fun:{int str -> int}={x y -> x+y}; fun(2,3)", "3 is not a *str",41);
269  // Test that the type-check is on the variable and not the function.
270  test_obj("fun={x y -> x*2}; bar:{int str -> int} = fun; baz:{int @{x;y} -> int} = fun; (fun(2,3),bar(2,\"abc\"))",
271  TypeStruct.make(TypeStruct.tups(TypeInt.con(4),TypeInt.con(4))));
272  testerr("fun={x y -> x+y}; baz:{int @{x;y} -> int} = fun; (fun(2,3), baz(2,3))",
273  "3 is not a *@{x:=; y:=; ...}", 66);
274  testerr("fun={x y -> x+y}; baz={x:int y:@{x;y} -> foo(x,y)}; (fun(2,3), baz(2,3))",
275  "Unknown ref 'foo'", 41);
276  // This test failed because the inner fun does not inline until GCP,
277  // and then it resolves and lifts the DISPLAY (which after resolution
278  // is no longer needed). Means: cannot resolve during GCP and preserve
279  // monotonicity. Would like '.fun' to load BEFORE GCP.
280  testerr("fun={x y -> x+y}; baz={x:int y:@{x;y} -> fun(x,y)}; (fun(2,3), baz(2,3))",
281  "3 is not a *@{x:=; y:=; ...}", 69);
282 
283  testerr("x=3; fun:{int->int}={x -> x*2}; fun(2.1)+fun(x)", "2.1 is not a int64",36);
284  test("x=3; fun:{real->real}={x -> x*2}; fun(2.1)+fun(x)", TypeFlt.con(2.1*2+3*2)); // Mix of types to fun()
285  test("fun:{real->flt32}={x -> x}; fun(123 )", TypeInt.con(123 ));
286  test("fun:{real->flt32}={x -> x}; fun(0.125)", TypeFlt.con(0.125));
287  testerr("fun:{real->flt32}={x -> x}; fun(123456789)", "123456789 is not a flt32",3);
288 
289  // Named types
290  test_name("A= :( )" ); // Zero-length tuple
291  test_name("A= :( , )", Type.SCALAR); // One-length tuple
292  test_name("A= :( , ,)", Type.SCALAR ,Type.SCALAR );
293  test_name("A= :(flt, )", TypeFlt.FLT64 );
294  test_name("A= :(flt,int)", TypeFlt.FLT64,TypeInt.INT64);
295  test_name("A= :( ,int)", Type.SCALAR ,TypeInt.INT64);
296 
297  test_ptr("A= :(str?, int); A( \"abc\",2 )","A:(*\"abc\", 2)");
298  test_ptr("A= :(str?, int); A( (\"abc\",2) )","A:(*\"abc\", 2)");
299  testerr("A= :(str?, int)?","Named types are never nil",16);
300  }

References com.cliffc.aa.type.TypeFlt.con(), com.cliffc.aa.type.TypeInt.con(), com.cliffc.aa.type.TypeFlt.FLT64, com.cliffc.aa.type.TypeInt.INT64, com.cliffc.aa.type.TypeFlt.make(), com.cliffc.aa.type.TypeStruct.make(), com.cliffc.aa.type.Type< T extends Type< T >.SCALAR, com.cliffc.aa.TestParse.test(), com.cliffc.aa.TestParse.test_name(), com.cliffc.aa.TestParse.test_obj(), com.cliffc.aa.TestParse.test_ptr(), com.cliffc.aa.TestParse.testerr(), com.cliffc.aa.type.TypeInt.TRUE, and com.cliffc.aa.type.TypeStruct.tups().

Here is the call graph for this function:

◆ testParse04()

void com.cliffc.aa.TestParse.testParse04 ( )

Definition at line 302 of file TestParse.java.

302  {
303  // simple anon struct tests
304  testerr("a=@{x=1.2;y}; x", "Unknown ref 'x'",14);
305  testerr("a=@{x=1;x=2}.x", "Cannot re-assign final field '.x' in @{x=1}",8);
306  test ("a=@{x=1.2;y;}; a.x", TypeFlt.con(1.2)); // standard "." field naming; trailing semicolon optional
307  test_ptr("x=@{n:=1;v:=2}; x.n := 3; x", "@{n:=3; v:=2}");
308  testerr("(a=@{x=0;y=0}; a.)", "Missing field name after '.'",17);
309  testerr("a=@{x=0;y=0}; a.x=1; a","Cannot re-assign final field '.x' in @{x=0; y=0}",16);
310  test ("a=@{x=0;y=1}; b=@{x=2} ; c=math_rand(1)?a:b; c.x", TypeInt.INT8); // either 0 or 2; structs can be partially merged
311  testerr("a=@{x=0;y=1}; b=@{x=2}; c=math_rand(1)?a:b; c.y", "Unknown field '.y' in @{x=int8}",46);
312  testerr("dist={p->p.x*p.x+p.y*p.y}; dist(@{x=1})", "Unknown field '.y' in @{x=1}",19);
313  test ("dist={p->p.x*p.x+p.y*p.y}; dist(@{x=1;y=2})", TypeInt.con(5)); // passed in to func
314  test ("dist={p->p.x*p.x+p.y*p.y}; dist(@{x=1;y=2;z=3})", TypeInt.con(5)); // extra fields OK
315  test ("dist={p:@{x;y} -> p.x*p.x+p.y*p.y}; dist(@{x:=1;y:=2})", TypeInt.con(5)); // Typed func arg
316  test ("a=@{x=(b=1.2)*b;y=b}; a.y", TypeFlt.con(1.2 )); // ok to use temp defs
317  test ("a=@{x=(b=1.2)*b;y=x}; a.y", TypeFlt.con(1.44)); // ok to use early fields in later defs
318  testerr("a=@{x=(b=1.2)*b;y=b}; b", "Unknown ref 'b'",22);
319  test ("t=@{n=0;val=1.2}; u=math_rand(1) ? t : @{n=t;val=2.3}; u.val", TypeFlt.NFLT64); // structs merge field-by-field
320  // Comments in the middle of a struct decl
321  test ("dist={p->p//qqq\n.//qqq\nx*p.x+p.y*p.y}; dist(//qqq\n@{x//qqq\n=1;y=2})", TypeInt.con(5));
322  testerr("@{x;y]","Expected closing '}' but found ']' instead",1);
323 
324  // Lexical scoping. Struct assignments make new fields, shadowing external variables.
325  test("x=@{a:=1;b=@{a= 2;b=@{a=3;b=0}}}; x.b.b.a",TypeInt.con(3));
326  // Lexical scoping. Before a new field is created, the external variable is used.
327  // After the new field, the new field is used.
328  test("x=@{a:=1;b=@{a=a+1;c=a}}; x.a*10+x.b.c",TypeInt.con(1*10+2));
329  // Similar to Python; if the first ref to a variable finds it in some
330  // (possibly external) scope, futher refs all refer to the same variable.
331  // Here 'a:=a+1' or 'a++' in the scope of 'b' increment the external variable.
332  // If the first ref to a variable is a set/store, then the variable
333  // is defined locally. Hence 'b=0' shadows the external x.b, and x.b
334  // is NOT set to 0.
335  test("x=@{a:=1;b= {a=a+1;b=0}}; x.b(); x.a",TypeInt.con(2));
336 
337  // Tuple
338  test_obj_isa("(0,\"abc\")", TypeStruct.make(Type.NIL,TypeMemPtr.OOP));
339  test("(1,\"abc\").0", TypeInt.TRUE);
340  test_obj("(1,\"abc\").1", TypeStr.ABC);
341 
342  // Named type variables
343  test("gal=:flt; gal", TypeFunPtr.make(TEST_FUNBITS,4, TypeMemPtr.NO_DISP));
344  test("gal=:flt; 3==gal(2)+1", TypeInt.TRUE);
345  test("gal=:flt; tank:gal = gal(2)", TypeInt.con(2).set_name("gal:"));
346  // test ("gal=:flt; tank:gal = 2.0", TypeName.make("gal",TypeFlt.con(2))); // TODO: figure out if free cast for bare constants?
347  testerr ("gal=:flt; tank:gal = gal(2)+1", "3 is not a gal:flt64",14);
348 
349  test ("Point=:@{x;y}; dist={p:Point -> p.x*p.x+p.y*p.y}; dist(Point(1,2))", TypeInt.con(5));
350  test ("Point=:@{x;y}; dist={p -> p.x*p.x+p.y*p.y}; dist(Point(1,2))", TypeInt.con(5));
351  testerr ("Point=:@{x;y}; dist={p:Point -> p.x*p.x+p.y*p.y}; dist((@{x=1;y=2}))", "*@{x=1; y=2} is not a *Point:@{x:=; y:=}",55);
352  testerr ("Point=:@{x;y}; Point((0,1))", "*(0, 1) is not a *Point:@{x:=; y:=}",21);
353  testerr("x=@{n: =1;}","Missing type after ':'",7);
354  testerr("x=@{n=;}","Missing ifex after assignment of 'n'",6);
355  test_obj_isa("x=@{n}",TypeStruct.make(TypeMemPtr.DISP_FLD,TypeFld.make("n",Type.XNIL,Access.RW,1)));
356  }

References com.cliffc.aa.type.TypeStr.ABC, com.cliffc.aa.type.TypeFlt.con(), com.cliffc.aa.type.TypeInt.con(), com.cliffc.aa.type.TypeMemPtr.DISP_FLD, com.cliffc.aa.type.TypeInt.INT8, com.cliffc.aa.type.TypeFld.make(), com.cliffc.aa.type.TypeFunPtr.make(), com.cliffc.aa.type.TypeStruct.make(), com.cliffc.aa.type.TypeFlt.NFLT64, com.cliffc.aa.type.Type< T extends Type< T >.NIL, com.cliffc.aa.type.TypeMemPtr.NO_DISP, com.cliffc.aa.type.TypeMemPtr.OOP, com.cliffc.aa.type.TypeFld.Access.RW, com.cliffc.aa.type.Type< T extends Type< T >.set_name(), com.cliffc.aa.TestParse.test(), com.cliffc.aa.TestParse.TEST_FUNBITS, com.cliffc.aa.TestParse.test_obj(), com.cliffc.aa.TestParse.test_obj_isa(), com.cliffc.aa.TestParse.test_ptr(), com.cliffc.aa.TestParse.testerr(), com.cliffc.aa.type.TypeInt.TRUE, and com.cliffc.aa.type.Type< T extends Type< T >.XNIL.

Here is the call graph for this function:

◆ testParse05()

void com.cliffc.aa.TestParse.testParse05 ( )

Definition at line 358 of file TestParse.java.

358  {
359  // nilable and not-nil pointers
360  test ("x:str? = 0", Type.XNIL); // question-type allows nil or not; zero digit is nil
361  test_obj("x:str? = \"abc\"", TypeStr.ABC); // question-type allows nil or not
362  testerr("x:str = 0", "0 is not a *str", 1);
363  test_ptr0("math_rand(1)?0:\"abc\"", (alias)->TypeMemPtr.make_nil(alias,TypeStr.ABC));
364  testerr("(math_rand(1)?0 : @{x=1}).x", "Struct might be nil when reading field '.x'", 26);
365  test ("p=math_rand(1)?0:@{x=1}; p ? p.x : 0", TypeInt.BOOL); // not-nil-ness after a nil-check
366  test ("x:int = y:str? = z:flt = 0", Type.XNIL); // nil/0 freely recasts
367  test ("\"abc\"==0", TypeInt.FALSE ); // No type error, just not nil
368  test ("\"abc\"!=0", TypeInt.TRUE ); // No type error, just not nil
369  test ("nil=0; \"abc\"!=nil", TypeInt.TRUE); // Another way to name nil
370  test ("a = math_rand(1) ? 0 : @{x=1}; // a is nil or a struct\n"+
371  "b = math_rand(1) ? 0 : @{c=a}; // b is nil or a struct\n"+
372  "b ? (b.c ? b.c.x : 0) : 0 // Nil-safe field load", TypeInt.BOOL); // Nested nil-safe field load
373  }

References com.cliffc.aa.type.TypeStr.ABC, com.cliffc.aa.type.TypeInt.BOOL, com.cliffc.aa.type.TypeInt.FALSE, com.cliffc.aa.type.TypeMemPtr.make_nil(), com.cliffc.aa.TestParse.test(), com.cliffc.aa.TestParse.test_obj(), com.cliffc.aa.TestParse.test_ptr0(), com.cliffc.aa.TestParse.testerr(), com.cliffc.aa.type.TypeInt.TRUE, and com.cliffc.aa.type.Type< T extends Type< T >.XNIL.

Here is the call graph for this function:

◆ testParse06()

void com.cliffc.aa.TestParse.testParse06 ( )

Definition at line 375 of file TestParse.java.

375  {
376  // Building recursive types
377  test("A= :int; A(1)", TypeInt.TRUE.set_name("A:"));
378  test_ptr("A= :(str?, int); A(0,2)","A:(0, 2)");
379  // Named recursive types
380  test_ptr("A= :(A?, int); A(0,2)",(alias) -> TypeMemPtr.make(alias,TypeStruct.make("A:",false,TypeStruct.tups(Type.XNIL,TypeInt.con(2)),false)));
381  test_ptr("A= :(A?, int); A(0,2)","A:(0, 2)");
382  test ("A= :@{n=A?; v=flt}; A(@{n=0;v=1.2}).v;", TypeFlt.con(1.2));
383  test_ptr("A= :(A?, int); A(A(0,2),3)","A:(*A:(0, 2), 3)");
384 
385  // TODO: Needs a way to easily test simple recursive types
386  TypeEnv te3 = Exec.go(Env.file_scope(Env.top_scope()),"args","A= :@{n=A?; v=int}; A(@{n=0;v=3})");
387  if( te3._errs != null ) System.err.println(te3._errs.toString());
388  assertNull(te3._errs);
389  TypeStruct tt3 = (TypeStruct)te3._tmem.ld((TypeMemPtr)te3._t);
390  assertEquals("A:", tt3._name);
391  assertTrue (tt3.at(0).is_display_ptr());
392  assertEquals(Type.XNIL ,tt3.at(1));
393  assertEquals(TypeInt.con(3),tt3.at(2));
394  assertEquals("n",tt3.fld(1)._fld);
395  assertEquals("v",tt3.fld(2)._fld);
396 
397  // Missing type B is also never worked on.
398  test_isa("A= :@{n=B?; v=int}", TypeFunPtr.GENERIC_FUNPTR);
399  test_isa("A= :@{n=B?; v=int}; a = A(0,2)", TypeMemPtr.ISUSED);
400  test_isa("A= :@{n=B?; v=int}; a = A(0,2); a.n", Type.NIL);
401  // Mutually recursive type
402  test_isa("A= :@{n=B; v=int}; B= :@{n=A; v=flt}", TypeFunPtr.GENERIC_FUNPTR);
403  test_isa("A= :@{n=B; v=int}; B= :@{n=A; v=flt}", TypeFunPtr.GENERIC_FUNPTR); // Same test, again, using the same Type.INTERN table
404  test_isa("A= :@{n=C?; v=int}; B= :@{n=A?; v=flt}; C= :@{n=B?; v=str}", TypeFunPtr.GENERIC_FUNPTR);
405  // Mixed ABC's, making little abc's in-between.
406  TypeMemPtr tmpA = TypeMemPtr.make(23,TypeStruct.make(TypeFld.NO_DISP,TypeFld.make("n",Type.XNIL,1),TypeFld.make("v",TypeInt.con(5 ),2)).set_name("A:"));
407  TypeMemPtr tmpB = TypeMemPtr.make(19,TypeStruct.make(TypeFld.NO_DISP,TypeFld.make("n",tmpA ,1),TypeFld.make("v",TypeFlt.con(3.14 ),2)).set_name("B:"));
408  TypeMemPtr tmpC = TypeMemPtr.make(35,TypeStruct.make(TypeFld.NO_DISP,TypeFld.make("n",tmpB ,1),TypeFld.make("v",TypeMemPtr.make(17,TypeStr.con("abc")),2)).set_name("C:"));
409  test_isa("A= :@{n=B?; v=int}; "+
410  "a= A(0,5); "+
411  "B= :@{n=A?; v=flt}; "+
412  "b= B(a,3.14);"+
413  "C= :@{n=B?; v=str};"+
414  "c= C(b,\"abc\");"+
415  "(a,b,c)",
416  TypeMemPtr.make(37,TypeStruct.make(TypeStruct.tups(tmpA,tmpB,tmpC))));
417  }

References com.cliffc.aa.TypeEnv._errs, com.cliffc.aa.type.TypeFld._fld, com.cliffc.aa.TypeEnv._t, com.cliffc.aa.TypeEnv._tmem, com.cliffc.aa.type.TypeStruct.at(), com.cliffc.aa.type.TypeFlt.con(), com.cliffc.aa.type.TypeInt.con(), com.cliffc.aa.type.TypeStr.con(), com.cliffc.aa.Env.file_scope(), com.cliffc.aa.type.TypeStruct.fld(), com.cliffc.aa.type.TypeFunPtr.GENERIC_FUNPTR, com.cliffc.aa.Exec.go(), com.cliffc.aa.type.Type< T extends Type< T >.is_display_ptr(), com.cliffc.aa.type.TypeMemPtr.ISUSED, com.cliffc.aa.type.TypeMem.ld(), com.cliffc.aa.type.TypeFld.make(), com.cliffc.aa.type.TypeMemPtr.make(), com.cliffc.aa.type.TypeStruct.make(), com.cliffc.aa.type.Type< T extends Type< T >.NIL, com.cliffc.aa.type.TypeFld.NO_DISP, com.cliffc.aa.type.Type< T extends Type< T >.set_name(), com.cliffc.aa.TestParse.test(), com.cliffc.aa.TestParse.test_isa(), com.cliffc.aa.TestParse.test_ptr(), com.cliffc.aa.Env.top_scope(), com.cliffc.aa.type.TypeInt.TRUE, com.cliffc.aa.type.TypeStruct.tups(), and com.cliffc.aa.type.Type< T extends Type< T >.XNIL.

Here is the call graph for this function:

◆ testParse07()

void com.cliffc.aa.TestParse.testParse07 ( )

Definition at line 419 of file TestParse.java.

419  {
420  // Passing a function recursively
421  test("f0 = { f x -> x ? f(f0(f,x-1),1) : 0 }; f0({&},2)", Type.XNIL);
422  test("f0 = { f x -> x ? f(f0(f,x-1),1) : 0 }; f0({+},2)", TypeInt.con(2));
423  test_isa("A= :@{n=A?; v=int}; f={x:A? -> x ? A(f(x.n),x.v*x.v) : 0}", TypeFunPtr.GENERIC_FUNPTR);
424  test ("A= :@{n=A?; v=flt}; f={x:A? -> x ? A(f(x.n),x.v*x.v) : 0}; f(A(0,1.2)).v;", TypeFlt.con(1.2*1.2));
425  test("tmp=((0,1.2),2.3); sq={x->x*x}; map={f t -> t ? (map(f,t.0),f t.1) : 0}; map(sq,tmp).1",TypeFlt.con(2.3*2.3));
426  // Calling a function twice which returns the same alias. Verify no pointer confusion.
427  test("noinline_x={@{a}}; x0=noinline_x(); x1=noinline_x(); x0.a:=2; x1.a", TypeInt.INT8);
428 
429  // Longer variable-length list (so no inline-to-trivial). Pure integer
430  // ops, no overload resolution. Does final stores into new objects
431  // interspersed with recursive computation calls.
432  test_obj_isa("map={x -> x ? @{nn=map(x.n);vv=x.v&x.v} : 0};"+
433  "map(@{n=math_rand(1)?0:@{n=math_rand(1)?0:@{n=math_rand(1)?0:@{n=0;v=1};v=2};v=3};v=4})",
434  TypeStruct.make(TypeMemPtr.DISP_FLD,TypeFld.make("nn",TypeMemPtr.STRUCT0,1),TypeFld.make("vv",TypeInt.INT8,2)));
435  // Test does loads after recursive call, which should be allowed to bypass.
436  test("sum={x -> x ? sum(x.n) + x.v : 0};"+
437  "sum(@{n=math_rand(1)?0:@{n=math_rand(1)?0:@{n=math_rand(1)?0:@{n=0;v=1};v=2};v=3};v=4})",
438  TypeInt.INT64);
439 
440  // User-defined linked list.
441  String ll_def = "List=:@{next;val};";
442  String ll_con = "tmp=List(List(0,1.2),2.3);";
443  String ll_map = "map = {fun list -> list ? List(map(fun,list.next),fun(list.val)) : 0};";
444  String ll_fun = "sq = {x -> x*x};";
445  String ll_apl = "map(sq,tmp);";
446 
447  test_isa(ll_def, TypeFunPtr.GENERIC_FUNPTR);
448  test(ll_def+ll_con+"; tmp.next.val", TypeFlt.con(1.2));
449  test_isa(ll_def+ll_con+ll_map, TypeFunPtr.GENERIC_FUNPTR);
450  test_isa(ll_def+ll_con+ll_map+ll_fun, TypeFunPtr.GENERIC_FUNPTR);
451 
452  // TODO: Needs a way to easily test simple recursive types
453  TypeEnv te4 = Exec.go(Env.file_scope(Env.top_scope()),"args",ll_def+ll_con+ll_map+ll_fun+ll_apl);
454  if( te4._errs != null ) System.err.println(te4._errs.toString());
455  assertNull(te4._errs);
456  TypeStruct tt4 = (TypeStruct)te4._tmem.sharpen((TypeMemPtr)te4._t)._obj;
457  assertEquals("List:", tt4._name);
458  TypeMemPtr tmp5 = (TypeMemPtr)tt4.at(1);
459  assertEquals(2.3*2.3,tt4.at(2).getd(),1e-6);
460  assertEquals("next",tt4.fld(1)._fld);
461  assertEquals("val" ,tt4.fld(2)._fld);
462 
463  // Test inferring a recursive struct type, with a little help
464  test_struct("map={x:@{n=;v=flt}? -> x ? @{nn=map(x.n);vv=x.v*x.v} : 0}; map(@{n=0;v=1.2})",
465  TypeStruct.make(TypeFld.NO_DISP,
466  TypeFld.make("nn",TypeMemPtr.make_nil(14,TypeObj.ISUSED),1),
467  TypeFld.make("vv",TypeFlt.con(1.2*1.2) ,2)));
468 
469  // Test inferring a recursive struct type, with less help. This one
470  // inlines so doesn't actually test inferring a recursive type.
471  test_struct("map={x -> x ? @{nn=map(x.n);vv=x.v*x.v} : 0}; map(@{n=0;v=1.2})",
472  TypeStruct.make(TypeFld.NO_DISP,
473  TypeFld.make("nn",TypeMemPtr.make_nil(23,TypeObj.ISUSED),1),
474  TypeFld.make("vv",TypeFlt.con(1.2*1.2) ,2)));
475 
476  // Test inferring a recursive struct type, with less help. Too complex to
477  // inline, so actual inference happens
478  test_obj_isa("map={x -> x ? @{nn=map(x.n);vv=x.v*x.v} : 0};"+
479  "map(@{n=math_rand(1)?0:@{n=math_rand(1)?0:@{n=math_rand(1)?0:@{n=0;v=1.2};v=2.3};v=3.4};v=4.5})",
480  TypeStruct.make(TypeMemPtr.DISP_FLD,
481  TypeFld.make("nn",TypeMemPtr.STRUCT0,1),
482  TypeFld.make("vv",TypeFlt.FLT64 ,2)));
483 
484  // Test inferring a recursive tuple type, with less help. This one
485  // inlines so doesn't actually test inferring a recursive type.
486  test_ptr("map={x -> x ? (map(x.0),x.1*x.1) : 0}; map((0,1.2))",
487  (alias) -> TypeMemPtr.make(alias,TypeStruct.make(TypeStruct.tups(Type.XNIL,TypeFlt.con(1.2*1.2)))));
488 
489  test_obj_isa("map={x -> x ? (map(x.0),x.1*x.1) : 0};"+
490  "map((math_rand(1)?0: (math_rand(1)?0: (math_rand(1)?0: (0,1.2), 2.3), 3.4), 4.5))",
491  TypeStruct.make(TypeMemPtr.STRUCT0,TypeFlt.FLT64));
492  }

References com.cliffc.aa.TypeEnv._errs, com.cliffc.aa.type.TypeFld._fld, com.cliffc.aa.TypeEnv._t, com.cliffc.aa.TypeEnv._tmem, com.cliffc.aa.type.TypeStruct.at(), com.cliffc.aa.type.TypeFlt.con(), com.cliffc.aa.type.TypeInt.con(), com.cliffc.aa.type.TypeMemPtr.DISP_FLD, com.cliffc.aa.Env.file_scope(), com.cliffc.aa.type.TypeStruct.fld(), com.cliffc.aa.type.TypeFlt.FLT64, com.cliffc.aa.type.TypeFunPtr.GENERIC_FUNPTR, com.cliffc.aa.type.Type< T extends Type< T >.getd(), com.cliffc.aa.Exec.go(), com.cliffc.aa.type.TypeInt.INT64, com.cliffc.aa.type.TypeInt.INT8, com.cliffc.aa.type.TypeObj< O extends TypeObj< O >.ISUSED, com.cliffc.aa.type.TypeFld.make(), com.cliffc.aa.type.TypeMemPtr.make(), com.cliffc.aa.type.TypeStruct.make(), com.cliffc.aa.type.TypeMemPtr.make_nil(), com.cliffc.aa.type.TypeFld.NO_DISP, com.cliffc.aa.type.TypeMem.sharpen(), com.cliffc.aa.type.TypeMemPtr.STRUCT0, com.cliffc.aa.TestParse.test(), com.cliffc.aa.TestParse.test_isa(), com.cliffc.aa.TestParse.test_obj_isa(), com.cliffc.aa.TestParse.test_ptr(), com.cliffc.aa.TestParse.test_struct(), com.cliffc.aa.Env.top_scope(), com.cliffc.aa.type.TypeStruct.tups(), and com.cliffc.aa.type.Type< T extends Type< T >.XNIL.

Here is the call graph for this function:

◆ testParse08()

void com.cliffc.aa.TestParse.testParse08 ( )

Definition at line 495 of file TestParse.java.

495  {
496  // Main issue with the map() test is final assignments crossing recursive
497  // not-inlined calls. Smaller test case:
498  test_ptr("tmp=@{val=2;nxt=@{val=1;nxt=0}}; noinline_map={tree -> tree ? @{vv=tree.val&tree.val;nn=noinline_map(tree.nxt)} : 0}; noinline_map(tmp)",
499  "@{vv=int8; nn=*$?}");
500 
501  // Too big to inline, multi-recursive
502  test_ptr("tmp=@{"+
503  " l=@{"+
504  " l=@{ l=0; r=0; v=3 };"+
505  " r=@{ l=0; r=0; v=7 };"+
506  " v=5"+
507  " };"+
508  " r=@{"+
509  " l=@{ l=0; r=0; v=15 };"+
510  " r=@{ l=0; r=0; v=22 };"+
511  " v=20"+
512  " };"+
513  " v=12 "+
514  "};"+
515  "map={tree -> tree"+
516  " ? @{ll=map(tree.l);rr=map(tree.r);vv=tree.v&tree.v}"+
517  " : 0};"+
518  "map(tmp)",
519  "@{ll=*$?; rr=$; vv=int8}");
520 
521 
522  // Failed attempt at a Tree-structure inference test. Triggered all sorts
523  // of bugs and error reporting issues, so keeping it as a regression test.
524  testerr("tmp=@{"+
525  " l=@{"+
526  " l=@{ l=0; v=3 };"+
527  " l=0;"+
528  " v=5"+
529  " };"+
530  " v=12 "+
531  "};"+
532  "map={tree -> tree"+
533  " ? @{ll=map(tree.l);vv=tree.v}"+
534  " : 0};"+
535  "map(tmp)",
536  "Cannot re-assign final field '.l' in @{l=*use; v:=0}",36);
537 
538  // Good tree-structure inference test
539  test_ptr("tmp=@{"+
540  " l=@{"+
541  " l=@{ l=0; r=0; v=3 };"+
542  " r=@{ l=0; r=0; v=7 };"+
543  " v=5"+
544  " };"+
545  " r=@{"+
546  " l=@{ l=0; r=0; v=15 };"+
547  " r=@{ l=0; r=0; v=22 };"+
548  " v=20"+
549  " };"+
550  " v=12 "+
551  "};"+
552  "map={tree fun -> tree"+
553  " ? @{l=map(tree.l,fun);r=map(tree.r,fun);v=fun(tree.v)}"+
554  " : 0};"+
555  "map(tmp,{x->x+x})",
556  "@{l=*$?; r=$; v=int64}");
557 
558  // A linked-list mixing ints and strings, always in pairs
559  String ll_cona = "a=0; ";
560  String ll_conb = "b=math_rand(1) ? ((a,1),\"abc\") : a; ";
561  String ll_conc = "c=math_rand(1) ? ((b,2),\"def\") : b; ";
562  String ll_cond = "d=math_rand(1) ? ((c,3),\"ghi\") : c; ";
563  String ll_cone = "e=math_rand(1) ? ((d,4),\"jkl\") : d; ";
564  String ll_cont = "tmp=e; ";
565  // Standard pair-UN-aware map call
566  String ll_map2 = "map = {fun list -> list ? (map(fun,list.0),fun(list.1)) : 0};";
567  String ll_fun2 = "plus = {x -> x+x};";
568  String ll_apl2 = "map(plus,tmp);";
569  // End type: ((((*?,scalar)?,str)?,int64),str)?
570 
571  // After inlining once, we become pair-aware.
572 
573  TypeStruct xts_int = TypeStruct.make(TypeMemPtr.OOP0,TypeInt.INT64);
574  TypeMemPtr xpt_int = TypeMemPtr.make(BitsAlias.RECORD_BITS0,xts_int);
575  TypeStruct xts_str = TypeStruct.make(xpt_int,TypeMemPtr.STRPTR);
576  TypeMemPtr xtmp = TypeMemPtr.make(BitsAlias.RECORD_BITS0,xts_str);
577 
578  test_isa(ll_cona+ll_conb+ll_conc+ll_cond+ll_cone+ll_cont+ll_map2+ll_fun2+ll_apl2,xtmp);
579  }

References com.cliffc.aa.type.TypeInt.INT64, com.cliffc.aa.type.TypeMemPtr.make(), com.cliffc.aa.type.TypeStruct.make(), com.cliffc.aa.type.TypeMemPtr.OOP0, com.cliffc.aa.type.BitsAlias.RECORD_BITS0, com.cliffc.aa.type.TypeMemPtr.STRPTR, com.cliffc.aa.TestParse.test_isa(), com.cliffc.aa.TestParse.test_ptr(), and com.cliffc.aa.TestParse.testerr().

Here is the call graph for this function:

◆ testParse09()

void com.cliffc.aa.TestParse.testParse09 ( )

Definition at line 581 of file TestParse.java.

581  {
582  // Test re-assignment
583  test("x=1", TypeInt.TRUE);
584  test("x=y=1", TypeInt.TRUE);
585  testerr("x=y=", "Missing ifex after assignment of 'y'",4);
586  testerr("x=z" , "Unknown ref 'z'",2);
587  testerr("x=1+y","Unknown ref 'y'",4);
588 
589  test("x:=1", TypeInt.TRUE);
590  test_obj("x:=0; a=x; x:=1; b=x; x:=2; (a,b,x)", TypeStruct.make(TypeStruct.tups(Type.XNIL,TypeInt.con(1),TypeInt.con(2))));
591 
592  testerr("x=1; x:=2; x", "Cannot re-assign final val 'x'", 5);
593  testerr("x=1; x =2; x", "Cannot re-assign final val 'x'", 5);
594 
595  test("math_rand(1)?(x=4):(x=3);x", TypeInt.NINT8); // x defined on both arms, so available after
596  test("math_rand(1)?(x:=4):(x:=3);x", TypeInt.NINT8); // x defined on both arms, so available after
597  test("math_rand(1)?(x:=4):(x:=3);x:=x+1", TypeInt.INT64); // x mutable on both arms, so mutable after
598  test ("x:=0; 1 ? (x:=4):; x:=x+1", TypeInt.con(5)); // x mutable ahead; ok to mutate on 1 arm and later
599  test ("x:=0; 1 ? (x =4):; x", TypeInt.con(4)); // x final on 1 arm, dead on other arm
600  testerr("x:=0; math_rand(1) ? (x =4):3; x=2; x", "Cannot re-assign read-only val 'x'",31);
601  // A final store, but defs of @{a} do not escape into nonline_x, hence do
602  // not merge and escape out.
603  test("noinline_x={@{a}}; noinline_x().a=2; noinline_x().a", TypeInt.INT8);
604  }

References com.cliffc.aa.type.TypeInt.con(), com.cliffc.aa.type.TypeInt.INT64, com.cliffc.aa.type.TypeInt.INT8, com.cliffc.aa.type.TypeStruct.make(), com.cliffc.aa.type.TypeInt.NINT8, com.cliffc.aa.TestParse.test(), com.cliffc.aa.TestParse.test_obj(), com.cliffc.aa.TestParse.testerr(), com.cliffc.aa.type.TypeInt.TRUE, com.cliffc.aa.type.TypeStruct.tups(), and com.cliffc.aa.type.Type< T extends Type< T >.XNIL.

Here is the call graph for this function:

◆ testParse10()

void com.cliffc.aa.TestParse.testParse10 ( )

Definition at line 623 of file TestParse.java.

623  {
624  // Test re-assignment in struct
625  test_obj_isa("x=@{n:=1;v:=2}", TypeStruct.make(TypeMemPtr.DISP_FLD,
626  TypeFld.make("n",TypeInt.con(1),Access.RW,1),
627  TypeFld.make("v",TypeInt.con(2),Access.RW,2)));
628  testerr ("x=@{n =1;v:=2}; x.n = 3; x.n", "Cannot re-assign final field '.n' in @{n=1; v:=2}",18);
629  test ("x=@{n:=1;v:=2}; x.n = 3", TypeInt.con(3));
630  test_ptr("x=@{n:=1;v:=2}; x.n := 3; x", "@{n:=3; v:=2}");
631  testerr ("x=@{n:=1;v:=2}; x.n = 3; x.v = 1; x.n = 4; x.n", "Cannot re-assign final field '.n' in @{n=3; v=1}",37);
632  test ("x=@{n:=1;v:=2}; y=@{n=3;v:=4}; tmp = math_rand(1) ? x : y; tmp.n", TypeInt.NINT8);
633  testerr ("x=@{n:=1;v:=2}; y=@{n=3;v:=4}; tmp = math_rand(1) ? x : y; tmp.n = 5; tmp.n", "Cannot re-assign read-only field '.n' in @{n==nint8; v:=nint8}",63);
634  test ("x=@{n:=1;v:=2}; foo={q -> q.n=3}; foo(x); x.n",TypeInt.con(3)); // Side effects persist out of functions
635  // Tuple assignment
636  testerr ("x=(1,2); x.0=3; x", "Cannot re-assign final field '.0' in (1, 2)",11);
637  // Final-only and read-only type syntax.
638  testerr ("ptr2rw = @{f:=1}; ptr2final:@{f=} = ptr2rw; ptr2final", "*@{f:=1} is not a *@{f=; ...}",27); // Cannot cast-to-final
639 
640  test_obj_isa("ptr2 = @{f =1}; ptr2final:@{f=} = ptr2 ; ptr2final", // Good cast
641  TypeStruct.make(TypeMemPtr.DISP_FLD,TypeFld.make("f",TypeInt.con(1),1)));
642  testerr ("ptr=@{f=1}; ptr2rw:@{f:=} = ptr; ptr2rw", "*@{f=1} is not a *@{f:=; ...}", 18); // Cannot cast-away final
643  test ("ptr=@{f=1}; ptr2rw:@{f:=} = ptr; 2", TypeInt.con(2)); // Dead cast-away of final
644  test ("@{x:=1;y =2}:@{x;y=}.y", TypeInt.con(2)); // Allowed reading final field
645  testerr ("f={ptr2final:@{x;y=} -> ptr2final.y }; f(@{x:=1;y:=2})", "*@{x:=1; y:=2} is not a *@{x:=; y=; ...}",42); // Another version of casting-to-final
646  testerr ("f={ptr2final:@{x;y=} -> ptr2final.y=3; ptr2final}; f(@{x:=1;y =2})", "Cannot re-assign final field '.y' in @{x:=1; y=2}",34);
647  test ("f={ptr:@{x==;y:=} -> ptr.y=3; ptr}; f(@{x:=1;y:=2}).y", TypeInt.con(3)); // On field x, cast-away r/w for r/o
648  test ("f={ptr:@{x=;y:=} -> ptr.y=3; ptr}; f(@{x =1;y:=2}).y", TypeInt.con(3)); // On field x, cast-up r/o for final but did not read
649  testerr ("f={ptr:@{x=;y:=} -> ptr.y=3; ptr}; f(@{x:=1;y:=2}).x", "*@{x:=1; y:=2} is not a *@{x=; y:=; ...}",37); // On field x, cast-up r/w for final and read
650  test ("f={ptr:@{x;y} -> ptr.y }; f(@{x:=1;y:=2}:@{x;y==})", TypeInt.con(2)); // cast r/w to r/o, and read
651  test ("f={ptr:@{x==;y==} -> ptr }; f(@{x=1;y=2}).y", TypeInt.con(2)); // cast final to r/o and read
652  test ("ptr=@{f:=1}; ptr:@{f=}.f=2",TypeInt.con(2)); // Checking that it is-a final does not make it final
653  // In general for these next two, want a 'MEET' style type assertion where
654  // locally at the function parm we "finalize" ptr.y, so the function body
655  // cannot modify it. However, no final store occurs so after the function,
656  // ptr.y remains writable.
657  testerr ("f={ptr:@{x;y=} -> ptr.y=3}; f(@{x:=1;y:=2});", "*@{x:=1; y:=2} is not a *@{x:=; y=; ...}",30);
658  //testerr ("f={ptr:@{x;y} -> ptr.y=3}; f(@{x:=1;y:=2}:@{x;y=})", "*@{.==nScalar} is not a *@{x:=; y:=; ...}",29);
659  test ("ptr=@{a:=1}; val=ptr.a; ptr.a=2; val",TypeInt.con(1));
660  // Allowed to build final pointer cycles
661  test ("ptr0=@{p:=0;v:=1}; ptr1=@{p=ptr0;v:=2}; ptr0.p=ptr1; ptr0.p.v+ptr1.p.v+(ptr0.p==ptr1)", TypeInt.con(4)); // final pointer-cycle is ok
662  }

References com.cliffc.aa.type.TypeInt.con(), com.cliffc.aa.type.TypeMemPtr.DISP_FLD, com.cliffc.aa.type.TypeFld.make(), com.cliffc.aa.type.TypeStruct.make(), com.cliffc.aa.type.TypeInt.NINT8, com.cliffc.aa.type.TypeFld.Access.RW, com.cliffc.aa.TestParse.test(), com.cliffc.aa.TestParse.test_obj_isa(), com.cliffc.aa.TestParse.test_ptr(), and com.cliffc.aa.TestParse.testerr().

Here is the call graph for this function:

◆ testParse11()

void com.cliffc.aa.TestParse.testParse11 ( )

Definition at line 665 of file TestParse.java.

665  {
666  test("x:=0; {1 ? ^2; x=3}(); x",Type.XNIL); // Following statement is ignored
667  test("{ ^3; 5}()",TypeInt.con(3)); // early exit
668  test("x:=0; {^3; x++}(); x",Type.XNIL); // Following statement is ignored
669  test("x:=0; {^1 ? (x=1); x=3}(); x",TypeInt.con(1)); // Return of an ifex
670  test("x:=0; {^1 ? x=1 ; x=3}(); x",TypeInt.con(1)); // Return of an ifex
671  test("f={0 ? ^0; 7}; f()", TypeInt.con(7));
672  // Find: returns 0 if not found, or first element which passes predicate.
673  test("find={list pred -> !list ? ^0; pred(list.1) ? ^list.1; find(list.0,pred)}; find(((0,3),2),{e -> e&1})", TypeInt.con(3));
674  test("x:=0; {1 ? ^2; x=3}(); x",Type.XNIL); // Following statement is ignored
675  // Curried functions
676  test("for={A-> A+3 }; for 2 ", TypeInt.con(5));
677  test("for={A->{B->A+B}}; for 2 3", TypeInt.con(5));
678  test("for={pred->{body->!pred()?^;tmp=body(); tmp?^tmp;7}}; for {1}{0}", TypeInt.con(7));
679  }

References com.cliffc.aa.type.TypeInt.con(), com.cliffc.aa.TestParse.test(), and com.cliffc.aa.type.Type< T extends Type< T >.XNIL.

Here is the call graph for this function:

◆ testParse12()

void com.cliffc.aa.TestParse.testParse12 ( )

Definition at line 682 of file TestParse.java.

682  {
683  test("incA= {cnt:=0; {cnt++} }(); incA();incA()",TypeInt.con(1));
684  test("cnt:=0; incA={cnt++}; incA();incA()+cnt",TypeInt.con(1+2));
685  test("incA= {cnt:=0; {cnt++} }(); incA() ",Type.XNIL);
686  test("incA= {cnt:=0; {cnt++} }(); incA();incA()",TypeInt.con(1));
687  test("tmp = {cnt:=0;({cnt++},{cnt})}();incA=tmp.0;getA=tmp.1;incA();incA()+getA()",TypeInt.con(1+2));
688  test("gen = {cnt:=0;({cnt++},{cnt})};" +
689  "tmp:=gen(); incA=tmp.0;getA=tmp.1;"+
690  "tmp:=gen(); incB=tmp.0;getB=tmp.1;"+
691  "incA();incB();incA(); getA()*10+getB()",
692  TypeInt.con(2*10+1));
693  }

References com.cliffc.aa.type.TypeInt.con(), com.cliffc.aa.TestParse.test(), and com.cliffc.aa.type.Type< T extends Type< T >.XNIL.

Here is the call graph for this function:

◆ testParse13()

void com.cliffc.aa.TestParse.testParse13 ( )

Definition at line 706 of file TestParse.java.

706  {
707  test(DO+"i:=0; do {i++ < 2} {i== 9}; i",TypeInt.con(3)); // Late exit, body never returns true.
708  test(FORELSE+"i:=0; for {i++ < 100} {i== 5} ",TypeInt.BOOL); // Not sure of exit value, except bool
709  test(FORELSE+"i:=0; for {i++ < 100} {i==50?i}",TypeInt.INT64); // Early exit on condition i==50
710  test(DO+"sum:=0; i:=0; do {i++ < 100} {sum:=sum+i}; sum",TypeInt.INT64);
711  }

References com.cliffc.aa.type.TypeInt.BOOL, com.cliffc.aa.type.TypeInt.con(), com.cliffc.aa.TestParse.DO, com.cliffc.aa.TestParse.FORELSE, com.cliffc.aa.type.TypeInt.INT64, and com.cliffc.aa.TestParse.test().

Here is the call graph for this function:

◆ testParse14()

void com.cliffc.aa.TestParse.testParse14 ( )

Definition at line 714 of file TestParse.java.

714  {
715  test_ptr("[3]", "[$]0/obj");
716  test ("ary = [3]; ary[0]", Type.XNIL);
717  test ("[3][0]", Type.XNIL);
718  test ("ary = [3]; ary[0]:=2", TypeInt.con(2));
719  test_obj("ary = [3]; ary[0]:=0; ary[1]:=1; ary[2]:=2; (ary[0],ary[1],ary[2])", // array create, array storing
720  TypeStruct.make(TypeStruct.tups(TypeInt.INT8,TypeInt.INT8,TypeInt.INT8)));
721  testary("0[0]","0 is not a *[]Scalar/obj",1);
722  testary("[3] [4]","Index must be out of bounds",5);
723  testary("[3] [-1]","Index must be out of bounds",5);
724  test_obj("[3]:[int]", TypeAry.make(TypeInt.con(3),Type.XNIL,TypeObj.OBJ)); // Array of 3 XNILs in INTs.
725  //test("[1,2,3]", TypeAry.make(TypeInt.con(1),TypeInt.con(3),TypeInt.INT8)); // Array of 3 elements
726  test("ary=[3];#ary",TypeInt.con(3)); // Array length
727  test_ptr(DO+"ary=[99]; i:=0; do {i++ < #ary} {ary[i]:=i*i};ary", "[$]int64/obj"); // sequential iteration over array
728  // ary.{e -> f(e)} // map over array elements
729  // ary.{e -> f(e)}.{e0 e1 -> f(e0,e1) } // map/reduce over array elements
730  }

References com.cliffc.aa.type.TypeInt.con(), com.cliffc.aa.TestParse.DO, com.cliffc.aa.type.TypeInt.INT8, com.cliffc.aa.type.TypeAry.make(), com.cliffc.aa.type.TypeStruct.make(), com.cliffc.aa.type.TypeObj< O extends TypeObj< O >.OBJ, com.cliffc.aa.TestParse.test(), com.cliffc.aa.TestParse.test_obj(), com.cliffc.aa.TestParse.test_ptr(), com.cliffc.aa.TestParse.testary(), com.cliffc.aa.type.TypeStruct.tups(), and com.cliffc.aa.type.Type< T extends Type< T >.XNIL.

Here is the call graph for this function:

◆ testParse15()

void com.cliffc.aa.TestParse.testParse15 ( )

Definition at line 735 of file TestParse.java.

735  {
736  TypeMemPtr tdisp = TypeMemPtr.make(BitsAlias.make0(2),TypeObj.ISUSED);
737  // Should be typable with H-M
738  test_ptr("noinline_map={lst fcn -> lst ? fcn lst.1};"+
739  "in_int=(0,2);"+ // List of ints
740  "in_str=(0,\"abc\");"+ // List of strings
741  "out_str =noinline_map(in_int,str:{int->str});"+ // Map over ints with int->str conversion, returning a list of strings
742  "out_bool=noinline_map(in_str,{str -> str==\"abc\"});"+ // Map over strs with str->bool conversion, returning a list of bools
743  "(out_str,out_bool)",
744  "(*\"2\",int1)");
745 
746  // ID in different contexts; in general requires a new TypeVar per use; for
747  // such a small function it is always inlined completely, has the same effect.
748  test("id={x->x};id(1)",TypeInt.con(1));
749  test("{x->x}(3.14)",TypeFlt.con(3.14));
750  test_prim("{x->x}({+})","+");
751  test("id={x->x};id({+})(id(1),id(math_pi))",TypeFlt.make(0,64,Math.PI+1));
752 
753  // Straight from TestHM.test08; types as {A -> (A,A)}.
754  // Function is never called, so returns the uncalled-function type.
755  test("fun={ g -> f={x -> g}; (f 3,f 1)}", TypeFunPtr.make(BitsFun.make0(46),ARG_IDX+1,Type.ANY));
756  // Called with different typevars A
757  test_ptr("fun={ g -> f={x -> g}; (f 3,f 1)}; (fun \"abc\",fun 3.14)",
758  "(*(*\"abc\", $), *(3.14, 3.14))");
759 
760  // recursive unification. Trivially types as a dead fcn ptr.
761  test_isa("x={x -> x x}",TypeFunPtr.make(BitsFun.make0(46),3,tdisp));
762  // recursive unification. Passing an ID to x then passes ID to ID, returning ID.
763  test_isa("x={x -> x x}; x({y->y})",TypeFunPtr.make(BitsFun.make0(47),4,tdisp));
764  // Looks like recursive unification, but x is a function of 0 arguments,
765  // being called with 1 argument. Error to call it.
766  testerr("x={x x};x(1)","Passing 1 arguments to x which takes 0 arguments",9);
767  // id accepts and returns both ints and reference types (arrays).
768  test_struct("noinline_id = {x->x};(noinline_id(5)&7, #noinline_id([3]))",
769  TypeStruct.make(TypeInt.INT8,TypeInt.con(3)));
770  // Should be typable with H-M
771  test_ptr("noinline_map={lst fcn -> lst ? fcn lst.1};"+
772  "in_int=(0,2);"+ // List of ints
773  "in_str=(0,\"abc\");"+ // List of strings
774  "out_str =noinline_map(in_int,str:{int->str});"+ // Map over ints with int->str conversion, returning a list of strings
775  "out_bool=noinline_map(in_str,{str -> str==\"abc\"});"+ // Map over strs with str->bool conversion, returning a list of bools
776  "(out_str,out_bool)",
777  "(*\"2\",int1)");
778  // Only odd thing here is losing not-nil-ness on list_int.
779  test_ptr("noinline_map={tup fcn -> (0,fcn tup.1)};"+
780  "lst_int=(0,2 );"+ //
781  "lst_str=(0,\"abc\");"+ //
782  "lst_istr=noinline_map(lst_int,str);"+ // Map over ints with int->str conversion, returning a list of strings
783  "lst_bool=noinline_map(lst_str,{str-> str==\"abc\"});"+ // Map over strs with str->bool conversion, returns bools
784  "(lst_istr,lst_bool)",
785  "(*(0, *\"2\")?, *(0, int1))");
786  // map being called with 2 different functions & lists
787  test("noinline_map={lst fcn -> lst ? (noinline_map(lst.0,fcn),fcn lst.1)};"+
788  "in_int=(((0,2),3),5);"+ // List of 3 ints
789  "in_str= ((0,\"abc\"),\"def\");"+ // List of 2 strings
790  "out_istr=noinline_map(in_int,str);"+ // Map over ints with int->str conversion, returning a list of strings
791  "out_bool=noinline_map(in_str,{str:str ->str==\"abc\"});"+ // Map over strs with str->bool conversion, returns bools
792  "(out_istr,out_bool)",
793  Type.ANY);
794 
795  }

References com.cliffc.aa.type.Type< T extends Type< T >.ANY, com.cliffc.aa.type.TypeFlt.con(), com.cliffc.aa.type.TypeInt.con(), com.cliffc.aa.type.TypeInt.INT8, com.cliffc.aa.type.TypeObj< O extends TypeObj< O >.ISUSED, com.cliffc.aa.type.TypeFlt.make(), com.cliffc.aa.type.TypeMemPtr.make(), com.cliffc.aa.type.TypeFunPtr.make(), com.cliffc.aa.type.TypeStruct.make(), com.cliffc.aa.type.BitsFun.make0(), com.cliffc.aa.type.BitsAlias.make0(), com.cliffc.aa.TestParse.test(), com.cliffc.aa.TestParse.test_isa(), com.cliffc.aa.TestParse.test_prim(), com.cliffc.aa.TestParse.test_ptr(), com.cliffc.aa.TestParse.test_struct(), and com.cliffc.aa.TestParse.testerr().

Here is the call graph for this function:

Member Data Documentation

◆ DO

final String com.cliffc.aa.TestParse.DO ="do={pred->{body->!pred()?^;body(); do pred body}};"
private

Definition at line 704 of file TestParse.java.

Referenced by com.cliffc.aa.TestParse.testParse13(), and com.cliffc.aa.TestParse.testParse14().

◆ FORELSE

final String com.cliffc.aa.TestParse.FORELSE ="for={pred->{body->!pred()?^;(tmp=body())?^tmp; for pred body}};"
private

Definition at line 700 of file TestParse.java.

Referenced by com.cliffc.aa.TestParse.testParse13().

◆ TEST_FUNBITS

final BitsFun com.cliffc.aa.TestParse.TEST_FUNBITS = BitsFun.make0(46)
staticprivate

Definition at line 16 of file TestParse.java.

Referenced by com.cliffc.aa.TestParse.testParse02(), and com.cliffc.aa.TestParse.testParse04().

The documentation for this class was generated from the following file:
com.cliffc.aa.type.TypeFld.Access.Final
Final
Definition: TypeFld.java:112
com.cliffc.aa.type.TypeStruct.sharpen
static TypeMemPtr sharpen(TypeMem mem, TypeMemPtr dull)
Definition: TypeStruct.java:875
com.cliffc.aa.type.TypeMemPtr.NO_DISP
static final Type NO_DISP
Definition: TypeMemPtr.java:80
com.cliffc.aa.type.BitsAlias.RECORD_BITS0
static BitsAlias RECORD_BITS0
Definition: BitsAlias.java:27
com.cliffc.aa.type.TypeInt.INT8
static final TypeInt INT8
Definition: TypeInt.java:42
com.cliffc.aa.type.TypeFunPtr
Definition: TypeFunPtr.java:23
com.cliffc.aa.type.TypeMemPtr.STRUCT0
static final TypeMemPtr STRUCT0
Definition: TypeMemPtr.java:102
com.cliffc.aa.type.BitsFun.make0
static BitsFun make0(int bit)
Definition: BitsFun.java:44
com.cliffc.aa.type.Type.isa
boolean isa(Type t)
Definition: Type.java:623
com.cliffc.aa.Env.lookup_valtype
Type lookup_valtype(String name)
Definition: Env.java:191
com.cliffc.aa.type.TypeMemPtr.OOP
static final TypeMemPtr OOP
Definition: TypeMemPtr.java:94
com.cliffc.aa.type.Type.SCALAR
static final Type SCALAR
Definition: Type.java:328
com.cliffc.aa.TestParse.TEST_FUNBITS
static final BitsFun TEST_FUNBITS
Definition: TestParse.java:16
com.cliffc.aa.Env.top_scope
static Env top_scope()
Definition: Env.java:72
com.cliffc.aa.TestParse.testerr
static void testerr(String program, String err, String cursor)
Definition: TestParse.java:928
com.cliffc.aa.type.TypeMemPtr.DISP_FLD
static final TypeFld DISP_FLD
Definition: TypeMemPtr.java:77
com.cliffc.aa.type.TypeFld
Definition: TypeFld.java:12
com.cliffc.aa.TestParse.test
static void test(String program, Type expected)
Definition: TestParse.java:846
com.cliffc.aa.TestParse.test_ptr0
static void test_ptr0(String program, Function< Integer, Type > expected)
Definition: TestParse.java:876
com.cliffc.aa.type.TypeInt
Definition: TypeInt.java:9
com.cliffc.aa.type.TypeFunPtr.GENERIC_FUNPTR
static final TypeFunPtr GENERIC_FUNPTR
Definition: TypeFunPtr.java:80
com.cliffc.aa.type.Type
an implementation of language AA
Definition: Type.java:94
com.cliffc.aa.type.TypeFlt
Definition: TypeFlt.java:9
com.cliffc.aa.TestParse.strip_alias_numbers
static String strip_alias_numbers(String err)
Definition: TestParse.java:939
com.cliffc.aa.type.BitsAlias
Definition: BitsAlias.java:8
com.cliffc.aa.type.TypeFld.Access.RW
RW
Definition: TypeFld.java:111
com.cliffc.aa.type.TypeFld.NO_DISP
static final TypeFld NO_DISP
Definition: TypeFld.java:170
com.cliffc.aa.type.TypeInt.con
static TypeInt con(long con)
Definition: TypeInt.java:37
com.cliffc.aa.type.TypeFunPtr.fidxs
BitsFun fidxs()
Definition: TypeFunPtr.java:127
com.cliffc.aa.type.TypeFlt.PI
static final TypeFlt PI
Definition: TypeFlt.java:40
com.cliffc.aa.type.Type.ANY
static final Type ANY
Definition: Type.java:325
com.cliffc.aa.type.TypeAry
Definition: TypeAry.java:7
com.cliffc.aa.type.TypeStruct
A memory-based collection of optionally named fields.
Definition: TypeStruct.java:50
com.cliffc.aa.type.TypeFld.make
static TypeFld make(String fld, Type t, int order)
Definition: TypeFld.java:58
com.cliffc.aa.type.Bits.test
static boolean test(long[] bits, int i)
Definition: Bits.java:224
com.cliffc.aa.type.TypeStruct.at
Type at(int idx)
Definition: TypeStruct.java:1013
com.cliffc.aa.type.Type.getd
double getd()
Definition: Type.java:804
com.cliffc.aa.TestParse.test_struct
static void test_struct(String program, TypeStruct expected)
Definition: TestParse.java:894
com.cliffc.aa.type.TypeInt.INT64
static final TypeInt INT64
Definition: TypeInt.java:39
com.cliffc.aa.type.Type.set_name
final T set_name(String name)
Definition: Type.java:551
com.cliffc.aa.type.TypeObj.OBJ
static final TypeObj OBJ
Definition: TypeObj.java:44
com.cliffc.aa.type.TypeObj
Definition: TypeObj.java:15
com.cliffc.aa.TestParse.test_ptr
static void test_ptr(String program, Function< Integer, Type > expected)
Definition: TestParse.java:868
com.cliffc.aa.type.TypeFlt.con
static Type con(double con)
Definition: TypeFlt.java:36
com.cliffc.aa.TestParse.test_obj_isa
static void test_obj_isa(String program, TypeObj expected)
Definition: TestParse.java:901
com.cliffc.aa.type.TypeFlt.make
static Type make(int x, int z, double con)
Definition: TypeFlt.java:30
com.cliffc.aa.TestParse.test_prim
static void test_prim(String program, String prim)
Definition: TestParse.java:851
com.cliffc.aa.type.TypeStr.ABC
static final TypeStr ABC
Definition: TypeStr.java:47
com.cliffc.aa.type.TypeAry.make
static TypeAry make(String name, boolean any, TypeInt sz, Type elem, TypeObj stor)
Definition: TypeAry.java:38
com.cliffc.aa.type.TypeInt.NINT8
static final TypeInt NINT8
Definition: TypeInt.java:47
com.cliffc.aa.type.TypeMemPtr.getbit
int getbit()
Definition: TypeMemPtr.java:263
com.cliffc.aa.type.TypeObj.ISUSED
static final TypeObj ISUSED
Definition: TypeObj.java:45
com.cliffc.aa.type.TypeFld._fld
String _fld
Definition: TypeFld.java:15
com.cliffc.aa.type.TypeStr.con
static TypeStr con(String con)
Definition: TypeStr.java:42
com.cliffc.aa.type.TypeFunPtr.make
static TypeFunPtr make(BitsFun fidxs, int nargs, Type disp)
Definition: TypeFunPtr.java:67
com.cliffc.aa.type.Type.sharptr
Type sharptr(Type ptr)
Definition: Type.java:930
com.cliffc.aa.Env.file_scope
static Env file_scope(Env top_scope)
Definition: Env.java:116
com.cliffc.aa.TestParse.test_isa
static void test_isa(String program, Type expected)
Definition: TestParse.java:922
com.cliffc.aa.type.TypeStr
Definition: TypeStr.java:14
com.cliffc.aa.util.VBitSet
Definition: VBitSet.java:5
com.cliffc.aa.type.TypeStruct.tups
static TypeFld[] tups(Type t1, Type t2)
Definition: TypeStruct.java:186
com.cliffc.aa.type.BitsFun
Definition: BitsFun.java:7
com.cliffc.aa.type.TypeObj.str
SB str(SB sb, VBitSet dups, TypeMem mem, boolean debug)
Definition: TypeObj.java:34
com.cliffc.aa.util.SB
Tight/tiny StringBuilder wrapper.
Definition: SB.java:8
com.cliffc.aa.type.Type.NIL
static final Type NIL
Definition: Type.java:332
com.cliffc.aa.TestParse.run
static TypeEnv run(String program)
Definition: TestParse.java:839
com.cliffc.aa.type.Type.is_display_ptr
boolean is_display_ptr()
Definition: Type.java:941
com.cliffc.aa.util.SB.nl
SB nl()
Definition: SB.java:48
com.cliffc.aa.type.BitsAlias.make0
static BitsAlias make0(int bit)
Definition: BitsAlias.java:72
com.cliffc.aa.type.TypeStruct.fld
TypeFld fld(int idx)
Definition: TypeStruct.java:1012
com.cliffc.aa.TestParse.testary
static void testary(String program, String err, int cur_off)
Definition: TestParse.java:951
com.cliffc.aa.type.TypeStruct.set_fld
TypeStruct set_fld(int i, Type t, Access ff)
Definition: TypeStruct.java:1030
com.cliffc.aa.util.SB.p
SB p(String s)
Definition: SB.java:13
com.cliffc.aa.type.TypeMemPtr._aliases
BitsAlias _aliases
Definition: TypeMemPtr.java:16
com.cliffc.aa.type.TypeInt.FALSE
static final Type FALSE
Definition: TypeInt.java:45
com.cliffc.aa.type.Bits.strip_nil
B strip_nil()
Definition: Bits.java:273
com.cliffc.aa.type.TypeStruct.make
static TypeStruct make(String fld_name, Type t)
Definition: TypeStruct.java:190
com.cliffc.aa.TestParse.FORELSE
final String FORELSE
Definition: TestParse.java:700
com.cliffc.aa.type.TypeMemPtr.ISUSED
static final TypeMemPtr ISUSED
Definition: TypeMemPtr.java:92
com.cliffc.aa.type.Type.XNIL
static final Type XNIL
Definition: Type.java:333
com.cliffc.aa.type.TypeFld.Access
Definition: TypeFld.java:109
com.cliffc.aa.type.TypeMemPtr.STRPTR
static final TypeMemPtr STRPTR
Definition: TypeMemPtr.java:97
com.cliffc.aa.type.TypeMemPtr.OOP0
static final TypeMemPtr OOP0
Definition: TypeMemPtr.java:93
com.cliffc.aa.TestParse.test_obj
static void test_obj(String program, TypeObj expected)
Definition: TestParse.java:886
com.cliffc.aa.type.TypeInt.TRUE
static final TypeInt TRUE
Definition: TypeInt.java:44
com.cliffc.aa.type.TypeMemPtr.make_nil
static TypeMemPtr make_nil(int alias, TypeObj obj)
Definition: TypeMemPtr.java:72
com.cliffc.aa.Env
Definition: Env.java:12
com.cliffc.aa.type.TypeInt.BOOL
static final TypeInt BOOL
Definition: TypeInt.java:43
com.cliffc.aa.util.SB.toString
String toString()
Definition: SB.java:62
com.cliffc.aa.type.TypeFlt.NFLT64
static final TypeFlt NFLT64
Definition: TypeFlt.java:41
com.cliffc.aa.type.TypeMemPtr
Definition: TypeMemPtr.java:14
com.cliffc.aa.TestParse.test_name
static void test_name(String program, Type... args)
Definition: TestParse.java:860
com.cliffc.aa.type.TypeFlt.FLT64
static final TypeFlt FLT64
Definition: TypeFlt.java:38
com.cliffc.aa.TestParse.DO
final String DO
Definition: TestParse.java:704
com.cliffc.aa.type.TypeMemPtr.make
static TypeMemPtr make(BitsAlias aliases, TypeObj obj)
Definition: TypeMemPtr.java:66