1.0.76 src

Author: SlimerDude

extras/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 ")

extras/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
   **

extras/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

extras/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]
   }
 

extras/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 }

extras/src/compiler/fan/namespace/GenericTypes.fan

@@ -82,6 +82,10 @@ abstract class GenericType : CType
     {
       t = parameterizeListType(nn)
     }
+    else if (nn is MapType)
+    {
+      t = parameterizeMapType(nn)
+    }
     else if (nn is FuncType)
     {
       t = parameterizeFuncType(nn)
@@ -99,6 +103,11 @@ abstract class GenericType : CType
     return parameterize(t.v).toListOf
   }
 
+  private CType parameterizeMapType(MapType t)
+  {
+    return MapType(parameterize(t.k), parameterize(t.v))
+  }
+
   private CType parameterizeFuncType(FuncType t)
   {
     CType[] params := t.params.map |CType p->CType| { parameterize(p) }

extras/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
 

extras/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)
@@ -444,7 +437,11 @@ class CheckErrors : CompilerStep
     t := p.paramType
     if (t.isVoid) { err("Cannot use Void as parameter type", p.loc); return }
     if (t.isThis)  { err("Cannot use This as parameter type", p.loc); return }
-    if (t.toNonNullable.signature != "|sys::This->sys::Void|") checkValidType(p.loc, t)
+    func := t.deref.toNonNullable as FuncType
+    if (func != null)
+      checkParamFuncType(p, func)
+    else
+      checkValidType(p.loc, t)
 
     // check parameter default type
     if (p.def != null && !p.paramType.isGenericParameter)
@@ -456,6 +453,19 @@ class CheckErrors : CompilerStep
     }
   }
 
+  private Void checkParamFuncType(ParamDef param, FuncType t)
+  {
+    if (!t.ret.isVoid && !t.ret.isValid)
+      err("Invalid return type '$t.ret' in func type of param '$param.name'", param.loc)
+
+    // This type is allowed in func params as a co-variant position
+    t.params.each |p|
+    {
+      if (!p.isThis && !p.isValid)
+        err("Invalid param type '$p' in func type of param '$param.name'", param.loc)
+    }
+  }
+
   private Void checkMethodReturn(MethodDef m)
   {
     if (m.ret.isThis)

extras/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_")

extras/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
   }