compiler: support for once methods on const classes

briansfrank · briansfrank · commit 7855f42ff120 · 2021-05-10T10:57:48.000-04:00
- Go ahead and make once a first class fcode flag (it was sort of odd case as compiler only flag previously).
- Use the once flag on the synthetic storage field for caching
- Check once + type.const in JVM emit and set volatile flag
diff --git a/src/compiler/fan/ast/AstWriter.fan b/src/compiler/fan/ast/AstWriter.fan
@@ -92,6 +92,7 @@ class AstWriter
     if (flags.and(FConst.Static)    != 0) w("static ")
     if (flags.and(FConst.Storage)   != 0) w("storage ")
     if (flags.and(FConst.Virtual)   != 0) w("virtual ")
+    if (flags.and(FConst.Once)      != 0) w("once ")
 
     if (flags.and(FConst.Synthetic) != 0) w("synthetic ")
     if (flags.and(FConst.Getter)    != 0) w("getter ")
diff --git a/src/compiler/fan/ast/MethodDef.fan b/src/compiler/fan/ast/MethodDef.fan
@@ -73,11 +73,6 @@ class MethodDef : SlotDef, CMethod
   **
   Bool isFieldSetter() { accessorFor != null && paramDefs.size == 1  }
 
-  **
-  ** Return if this is a once method
-  **
-  Bool isOnce() { flags.and(Parser.Once) != 0 }
-
   **
   ** Return if this is a constructor with an it-block as last parameter
   **
diff --git a/src/compiler/fan/fcode/FConst.fan b/src/compiler/fan/fcode/FConst.fan
@@ -41,7 +41,8 @@ mixin FConst
   const static Int Storage    := 0x00010000
   const static Int Synthetic  := 0x00020000
   const static Int Virtual    := 0x00040000
-  const static Int FlagsMask  := 0x0007ffff
+  const static Int Once       := 0x00080000
+  const static Int FlagsMask  := 0x000fffff
 
 //////////////////////////////////////////////////////////////////////////
 // MethodVarFlags
diff --git a/src/compiler/fan/fcode/FPrinter.fan b/src/compiler/fan/fcode/FPrinter.fan
@@ -249,6 +249,7 @@ class FPrinter : FConst
     if (flags.and(FConst.Storage)   != 0) s.add("storage ")
     if (flags.and(FConst.Synthetic) != 0) s.add("synthetic ")
     if (flags.and(FConst.Virtual)   != 0) s.add("virtual ")
+    if (flags.and(FConst.Once)      != 0) s.add("once ")
     return s.toStr[0..-2]
   }
 
diff --git a/src/compiler/fan/namespace/CSlot.fan b/src/compiler/fan/namespace/CSlot.fan
@@ -39,6 +39,7 @@ mixin CSlot
   Bool isStorage()   { flags.and(FConst.Storage)   != 0 }
   Bool isSynthetic() { flags.and(FConst.Synthetic) != 0 }
   Bool isVirtual()   { flags.and(FConst.Virtual)   != 0 }
+  Bool isOnce()      { flags.and(FConst.Once)      != 0 }
 
   Bool isInstanceCtor() { isCtor && !isStatic }
   Bool isStaticCtor() { isCtor && isStatic }
diff --git a/src/compiler/fan/parser/Parser.fan b/src/compiler/fan/parser/Parser.fan
@@ -283,7 +283,7 @@ public class Parser : CompilerSupport
         case Token.internalKeyword:  flags = flags.or(FConst.Internal);  protection = true
         case Token.nativeKeyword:    flags = flags.or(FConst.Native)
         case Token.newKeyword:       flags = flags.or(FConst.Ctor)
-        case Token.onceKeyword:      flags = flags.or(Once) // Parser only flag
+        case Token.onceKeyword:      flags = flags.or(FConst.Once)
         case Token.overrideKeyword:  flags = flags.or(FConst.Override)
         case Token.privateKeyword:   flags = flags.or(FConst.Private);   protection = true
         case Token.protectedKeyword: flags = flags.or(FConst.Protected); protection = true
@@ -466,7 +466,7 @@ public class Parser : CompilerSupport
     field := FieldDef(loc, parent)
     field.doc    = doc
     field.facets = facets
-    field.flags  = flags.and(ParserFlagsMask.not)
+    field.flags  = flags
     field.name   = name
     if (type != null) field.fieldType = type
 
@@ -2416,11 +2416,6 @@ public class Parser : CompilerSupport
 // Parser Flags
 //////////////////////////////////////////////////////////////////////////
 
-  // These are flags used only by the parser we merge with FConst
-  // flags by starting from most significant bit and working down
-  const static Int Once     := 0x8000_0000
-  const static Int ParserFlagsMask := 0
-
   // Bitwise and this mask to clear all protection scope flags
   const static Int ProtectionMask := (FConst.Public).or(FConst.Protected).or(FConst.Private).or(FConst.Internal).not
 
diff --git a/src/compiler/fan/steps/CheckErrors.fan b/src/compiler/fan/steps/CheckErrors.fan
@@ -119,7 +119,7 @@ class CheckErrors : CompilerStep
 
     // these modifiers are never allowed on a type
     if (flags.and(FConst.Ctor) != 0)      err("Cannot use 'new' modifier on type", loc)
-    if (flags.and(Parser.Once) != 0)      err("Cannot use 'once' modifier on type", loc)
+    if (flags.and(FConst.Once) != 0)      err("Cannot use 'once' modifier on type", loc)
     if (flags.and(FConst.Override) != 0)  err("Cannot use 'override' modifier on type", loc)
     if (flags.and(FConst.Private) != 0)   err("Cannot use 'private' modifier on type", loc)
     if (flags.and(FConst.Protected) != 0) err("Cannot use 'protected' modifier on type", loc)
@@ -177,16 +177,9 @@ class CheckErrors : CompilerStep
     // in another check
     t.fieldDefs.each |FieldDef f|
     {
-      if (!f.isConst && !f.isStatic && f.isStorage && !isSys)
+      if (!f.isConst && !f.isStatic && f.isStorage && !isSys && !f.isOnce)
         err("Const type '$t.name' cannot contain non-const field '$f.name'", f.loc)
     }
-
-    // check that no once methods
-    t.methodDefs.each |MethodDef m|
-    {
-      if (m.isOnce)
-        err("Const type '$t.name' cannot contain once method '$m.name'", m.loc)
-    }
   }
 
   private Void checkBase(TypeDef t, CType base)
@@ -256,7 +249,7 @@ class CheckErrors : CompilerStep
     // these modifiers are never allowed on a field
     if (flags.and(FConst.Ctor) != 0)    err("Cannot use 'new' modifier on field", loc)
     if (flags.and(FConst.Final) != 0)   err("Cannot use 'final' modifier on field", loc)
-    if (flags.and(Parser.Once) != 0)    err("Cannot use 'once' modifier on field", loc)
+    if (flags.and(FConst.Once) != 0 && flags.and(FConst.Synthetic) == 0) err("Cannot use 'once' modifier on field", loc)
 
     // check invalid protection combinations
     checkProtectionFlags(flags, loc)
@@ -380,7 +373,7 @@ class CheckErrors : CompilerStep
       if (flags.and(FConst.Abstract) != 0) err("Invalid combination of 'new' and 'abstract' modifiers", loc)
       else if (flags.and(FConst.Override) != 0) err("Invalid combination of 'new' and 'override' modifiers", loc)
       else if (flags.and(FConst.Virtual) != 0) err("Invalid combination of 'new' and 'virtual' modifiers", loc)
-      if (flags.and(Parser.Once) != 0)     err("Invalid combination of 'new' and 'once' modifiers", loc)
+      if (flags.and(FConst.Once) != 0)     err("Invalid combination of 'new' and 'once' modifiers", loc)
       if (flags.and(FConst.Native) != 0)   err("Invalid combination of 'new' and 'native' modifiers", loc)
     }
 
@@ -390,18 +383,18 @@ class CheckErrors : CompilerStep
       if (flags.and(FConst.Abstract) != 0) err("Invalid combination of 'static' and 'abstract' modifiers", loc)
       else if (flags.and(FConst.Override) != 0) err("Invalid combination of 'static' and 'override' modifiers", loc)
       else if (flags.and(FConst.Virtual) != 0) err("Invalid combination of 'static' and 'virtual' modifiers", loc)
-      if (flags.and(Parser.Once) != 0) err("Invalid combination of 'static' and 'once' modifiers", loc)
+      if (flags.and(FConst.Once) != 0) err("Invalid combination of 'static' and 'once' modifiers", loc)
     }
 
     // check invalid abstract flags
     if (flags.and(FConst.Abstract) != 0)
     {
       if (flags.and(FConst.Native) != 0) err("Invalid combination of 'abstract' and 'native' modifiers", loc)
-      if (flags.and(Parser.Once) != 0) err("Invalid combination of 'abstract' and 'once' modifiers", loc)
+      if (flags.and(FConst.Once) != 0) err("Invalid combination of 'abstract' and 'once' modifiers", loc)
     }
 
     // mixins cannot have once methods
-    if (flags.and(Parser.Once) != 0)
+    if (flags.and(FConst.Once) != 0)
     {
       if (curType.isMixin)
         err("Mixins cannot have once methods", m.loc)
diff --git a/src/compiler/fan/steps/Normalize.fan b/src/compiler/fan/steps/Normalize.fan
@@ -173,8 +173,7 @@ class Normalize : CompilerStep
     loc := m.loc
 
     // we'll report these errors in CheckErrors
-    if (curType.isConst || curType.isMixin ||
-        m.isStatic || m.isCtor || m.isFieldAccessor)
+    if (curType.isMixin || m.isStatic || m.isCtor || m.isFieldAccessor)
       return
 
     // error checking
@@ -184,7 +183,7 @@ class Normalize : CompilerStep
 
     // generate storage field
     f := FieldDef(loc, curType)
-    f.flags     = FConst.Private + FConst.Storage + FConst.Synthetic
+    f.flags     = FConst.Private + FConst.Storage + FConst.Synthetic + FConst.Once
     f.name      = m.name + "\$Store"
     f.fieldType = ns.objType.toNullable
     f.init      = Expr.makeForLiteral(loc, ns, "_once_")
diff --git a/src/compiler/fan/util/ApiDocWriter.fan b/src/compiler/fan/util/ApiDocWriter.fan
@@ -204,6 +204,7 @@ class ApiDocWriter
     if (flags.and(FConst.Synthetic) != 0) s.join("synthetic")
     if (flags.and(FConst.Virtual)   != 0) s.join("virtual")
     if (flags.and(FConst.Ctor)      != 0) s.join("new")
+    if (flags.and(FConst.Once)      != 0) s.join("once")
     return s.toStr
   }
 
diff --git a/src/compilerDoc/fan/model/DocFlags.fan b/src/compilerDoc/fan/model/DocFlags.fan
@@ -31,6 +31,7 @@ final const class DocFlags
   const static Int Storage    := 0x00010000
   const static Int Synthetic  := 0x00020000
   const static Int Virtual    := 0x00040000
+  const static Int Once       := 0x00080000
 
   static Bool isAbstract (Int flags) { flags.and(DocFlags.Abstract)  != 0 }
   static Bool isConst    (Int flags) { flags.and(DocFlags.Const)     != 0 }
@@ -51,6 +52,7 @@ final const class DocFlags
   static Bool isStorage  (Int flags) { flags.and(DocFlags.Storage)   != 0 }
   static Bool isSynthetic(Int flags) { flags.and(DocFlags.Synthetic) != 0 }
   static Bool isVirtual  (Int flags) { flags.and(DocFlags.Virtual)   != 0 }
+  static Bool isOnce     (Int flags) { flags.and(DocFlags.Once)      != 0 }
 
   static Int fromName(Str name)
   {
diff --git a/src/doc/docIntro/doc/ChangeLog.fandoc b/src/doc/docIntro/doc/ChangeLog.fandoc
@@ -8,11 +8,14 @@
 
 *Build 1.0.76 (working)*
 - Allow This to be in any func param position as method param
+- Allow once methods to be used on const classes
+- Add once as new fcode bitmask flag 0x80000
 - BoolArray clear, eachTrue, getAndSet
 - Int.clip, Float.clip
 - dom: Elem.fromNative fix if already Elem instance
 - domkit: SashBox.onSashResize
 - WebClient.authBasic
+- Minor enhancements to compilerDoc APIs
 
 *Build 1.0.75 (24 Aug 2020)*
 - Move repo from BitBucket to GitHub
diff --git a/src/doc/docLang/doc/Methods.fandoc b/src/doc/docLang/doc/Methods.fandoc
@@ -328,7 +328,6 @@ plate code:
   once Str fullName() { return "$firstName  $lastName" }
 
 Restrictions for once methods:
-  - Must not be declared within a const class
   - Must not be declared within a mixin
   - Must not be a constructor
   - Must not be static
@@ -340,6 +339,13 @@ If a once method throws an exception, then there is no cached
 value - subsequent calls will re-execute the method until it
 returns a value.
 
+A once method may be used on a const class with caveats.  In the JVM the
+cache field is compiled to a volatile field.  However, there is no
+guarantee that the method is called exactly once across multiple threads.
+So the computation must be a pure function that always returns the
+same value.  Furthermore there is no guarantee that all threads see the
+exact same instance returned.
+
 Covariance [#covariance]
 ************************
 Fantom supports [covariance]`Inheritance#covariance` - which allows
diff --git a/src/sys/java/fanx/emit/FTypeEmit.java b/src/sys/java/fanx/emit/FTypeEmit.java
@@ -146,7 +146,12 @@ protected void emit(FField f)
   {
     if ((f.flags & FConst.Storage) != 0)
     {
-      FieldEmit fe = emitField(f.name, pod.typeRef(f.type).jsig(), jflags(f.flags));
+      // make const class once fields volatile
+      int jflags = jflags(f.flags);
+      if ((f.flags & FConst.Once) != 0 && (type.flags & FConst.Const) != 0)
+        jflags |= EmitConst.VOLATILE;
+
+      FieldEmit fe = emitField(f.name, pod.typeRef(f.type).jsig(), jflags);
       FFacetEmit.emitField(fe, pod, f.attrs);
     }
   }
diff --git a/src/sys/java/fanx/fcode/FConst.java b/src/sys/java/fanx/fcode/FConst.java
@@ -42,7 +42,8 @@ public interface FConst
   public static final int Storage    = 0x00010000;
   public static final int Synthetic  = 0x00020000;
   public static final int Virtual    = 0x00040000;
-  public static final int FlagsMask  = 0x0007ffff;
+  public static final int Once       = 0x00080000;
+  public static final int FlagsMask  = 0x000fffff;
 
 //////////////////////////////////////////////////////////////////////////
 // MethodVarFlags
diff --git a/src/testCompiler/fan/CheckErrorsTest.fan b/src/testCompiler/fan/CheckErrorsTest.fan
@@ -631,7 +631,7 @@ class CheckErrorsTest : CompilerTest
         const [Num:Duration]? ok1   // ok
         const [Num:Str[][]]? ok2    // ok
 
-        once Int p() { return 3 }  // 30
+        once Int p() { return 3 }  // 30 ok now
       }
 
       class Bar {}
@@ -695,7 +695,9 @@ class CheckErrorsTest : CompilerTest
 
          1,  7, "Const type 'Foo' cannot subclass non-const class 'Bar'", // further tests in testConstInheritance
         22,  3, "Const type 'Foo' cannot contain non-const field 'j'",
+        /*
         30,  3, "Const type 'Foo' cannot contain once method 'p'",
+        */
 
         34,  1, "Non-const type 'Roo' cannot subclass const class 'Foo'",
         35, 25, "Const type 'Boo' cannot contain non-const field 'x'",
diff --git a/src/testCompiler/fan/CompilerTest.fan b/src/testCompiler/fan/CompilerTest.fan
@@ -36,6 +36,7 @@ abstract class CompilerTest : Test
     input.mode        = CompilerInputMode.str
     input.srcStr      = src
     input.srcStrLoc   = Loc.make("Script")
+    //input.fcodeDump = true
     f?.call(input)
 
     compiler = Compiler.make(input)
diff --git a/src/testCompiler/fan/MiscTest.fan b/src/testCompiler/fan/MiscTest.fan
@@ -604,6 +604,34 @@ class MiscTest : CompilerTest
        ])
   }
 
+//////////////////////////////////////////////////////////////////////////
+// Once Const
+//////////////////////////////////////////////////////////////////////////
+
+  Void testOnceConst()
+  {
+    compile(
+     "const class A
+      {
+        virtual once Str x() { Int.random.toStr }
+        once DateTime bad() { throw Err.make }
+      }
+
+      const class B : A
+      {
+        override Str x() { Int.random.toStr }
+      }
+      ")
+
+     a := pod.type("A").make
+     b := pod.type("B").make
+     verifySame(a->x, a->x)
+     verifyNotSame(b->x, b->x)
+     verifyErr(Err#) { a->bad }
+     verifyErr(Err#) { a->bad }
+     verifyErr(Err#) { a->bad }
+  }
+
 //////////////////////////////////////////////////////////////////////////
 // Func Types
 //////////////////////////////////////////////////////////////////////////

Original file line number	Diff line number	Diff line change
`@@ -249,6 +249,7 @@ class FPrinter : FConst`
`249`	`249`	`if (flags.and(FConst.Storage) != 0) s.add("storage ")`
`250`	`250`	`if (flags.and(FConst.Synthetic) != 0) s.add("synthetic ")`
`251`	`251`	`if (flags.and(FConst.Virtual) != 0) s.add("virtual ")`
	`252`	`+ if (flags.and(FConst.Once) != 0) s.add("once ")`
`252`	`253`	`return s.toStr[0..-2]`
`253`	`254`	`}`
`254`	`255`
Original file line number	Diff line number	Diff line change
`@@ -204,6 +204,7 @@ class ApiDocWriter`
`204`	`204`	`if (flags.and(FConst.Synthetic) != 0) s.join("synthetic")`
`205`	`205`	`if (flags.and(FConst.Virtual) != 0) s.join("virtual")`
`206`	`206`	`if (flags.and(FConst.Ctor) != 0) s.join("new")`
	`207`	`+ if (flags.and(FConst.Once) != 0) s.join("once")`
`207`	`208`	`return s.toStr`
`208`	`209`	`}`
`209`	`210`