set flag OurSyncCollections.

!include once #1034831 // Gazelle 22 Function Include for Testing

svoid test_leftArrowScript_classDefs() {
  var test = new TestFunctionValues<S, O>(l1 leftArrowVerbose);

  // define a class with two fields
  
  S classPrefix = "scriptClasses.";
  //LASClassLoader cl = new LASClassLoader(mc());
  temp LASMultiClassLoader cl = new(mc());

  embedded O runScript(S code) {  
    new GazelleV_LeftArrowScriptParser parser;
    enableScaffolding(parser);
    parser.classDefPrefix(classPrefix);
    parser.lasClassLoader(cl);
    ret leftArrowVerbose(parser, code);
  }

  S classSrc = [[
    class MyClass {
      a: String
      b: String
    }
  ]], src = classSrc;

  Class c = cast runScript(src);
  assertStartsWith(print(c.getName()), classPrefix + "MyClass" + "_");
  
  // compile same source again - make sure we get the same class object
  assertSame(c, runScript(src));
  
  assertEqualsVerbose("Number of fields", 2, l(getDeclaredFields_cached(c)));
  assertEqualsVerbose("Type of a", S.class, getField(c, "a").getType());
  assertEqualsVerbose("Type of b", S.class, getField(c, "b").getType());
  
  // Make sure a change in the class definition gives us a new class name
  Class c2 = cast runScript([[
    class MyClass {
      a: String
      c: String
    }
  ]]);
  print(className(c2));
  assertNotSame(c, c2);
  
  // Make sure a change in the methods also gives us a new class name
  S classSrc2 = [[
    class MyClass {
      def bla { "x" }
    }
  ]];
  c = (Class) runScript(classSrc2);
  assertSame(c, runScript(classSrc2));
  c2 = (Class) runScript([[
    class MyClass {
      def bla { "y" }
    }
  ]]);
  assertNotSame(c, c2);
  
  // Now let's try and use a script-defined class
  
  src = classSrc + [[
    x <- new MyClass
    y <- new MyClass
    x a <- "yo"
    y a <- "oy"
    x a
  ]];
  
  assertEqualsVerbose("yo", runScript(src));
  
  // Using the class in a function
  
  src = classSrc + [[
    def bla {
      x <- new MyClass
      x a <- "yo"
      x a
    }
    bla
  ]];
  
  assertEqualsVerbose("yo", runScript(src));
  
  // Now for defining some methods (yay!)
  
  src = [[
    class MyClass {
      def method1 { "I'm here" }
      def method2 a { reversed a }
    }
    
    x <- new MyClass
    pair (x method1) (x method2 "sey")
  ]];
  
  assertEqualsVerbose(pair("I'm here", "yes"), runScript(src));
  
  // accessing instance fields
  
  src = [[
    class MyClass {
      a: String
      
      def getA { this a } // requiring the this keyword for now
      def setA a { this a <- a }
      def aLength { (this a) length }
    }
    
    x <- new MyClass
    x setA "abc"
    assertEquals (x aLength) 3
    x getA
  ]];
  
  assertEqualsVerbose("abc", runScript(src));

  // fully qualified type  
  classSrc = [[
    class MyClass {
      a: java.util.List
    }
  ]];

  c = (Class) runScript(classSrc);
  assertEqualsVerbose(fieldType(c, "a"), L.class);
  
  // type with type parameter
  classSrc = [[
    class MyClass {
      a: L<S>
    }
  ]];

  c = (Class) runScript(classSrc);
  assertEqualsVerbose("Raw type of L<S> field", fieldType(c, "a"), L.class);
  assertEqualsVerbose("Generic type of L<S> field", genericFieldType(c, "a"),
    new ParameterizedTypeImpl(null, L, S));
    
  // primitive type
  classSrc = [[
    class MyClass {
      x: int
    }
  ]];

  c = (Class) runScript(classSrc);
  assertEqualsVerbose(fieldType(c, "x"), int.class);
}