class_super: synth derived ctor chains super + suppress 0-arg when user has ctor

Follow-up to #2892. Closes the synth-ctor side of the silent-bypass family.

PR1 made super(...) mandatory on every CFG path of a user-defined derived
ctor and hard-rejected super.X() skipping a user-coded intermediate. But it
left two gaps: (a) a fully empty class Derived : Base {} still got the
pre-existing 0-arg field-init synth ctor that never called Base's ctor, so
new Derived() silently bypassed Base's invariants; (b) a class with an
args-only user ctor (def Foo(int)) also got a pre-existing 0-arg synth that
silently bypassed the user ctor on new Foo(). Both close here.

S2  Synth-chain ctor for implicit-default-derived classes
    - InferTypes::visit(Structure*) now fires tryMakeStructureCtor when any
      ancestor has a user ctor (not just on field-init), so empty intermediates
      get a chain ctor that lets further-derived classes reach the deepest
      user code in one call.
    - makeConstructor emits a let-self / call ChainTarget-ChainTarget(self) /
      return self body when findChainCtorAncestor() returns non-null. The
      walk-past skips empty intermediates so the call lands on the closest
      user-ctored ancestor; that's required because intermediate synth ctors
      only register the factory (no (self : Mid) method form to walk to).

S2d Hard-error when no default ancestor ctor exists
    - If a synth-needed class's closest user-ctored ancestor has no 0-arg
      signature (or all-defaulted args), error 30322 (missing_super_call)
      fires with a fix-it pointing at the offending ancestor by name. New
      tests/language/failed_parent_no_default* cover the direct and skip-empty
      walks.

Option-A 0-arg synth suppression (the part Boris asked for)
    - tryMakeStructureCtor skips emission entirely when var->isClass and the
      class has any user ctor. Pre-PR2 daslang auto-synthesized a 0-arg field-
      init ctor whenever no 0-arg user ctor existed, which let new Class()
      silently bypass an args-only user ctor's invariants. Matches C++/Java/C#
      convention: providing any ctor opts out of the compiler-generated
      default. Structs keep the old behavior (no inheritance, no super to
      bypass). One in-tree fixture (cant_access_private_members.das) used the
      silent-bypass form and is updated to pass the required arg.

Lint walks ancestors
    - PR1's lint only triggered when fn->classParent->parent had a user ctor.
      With chain synth in place, an empty intermediate would propagate the
      requirement: C : B : A where B is empty and A has user ctor must lint
      C's user ctor for missing super(). lint now uses findChainCtorAncestor.
      Suggestion text and countSuperCalls target both update to the resolved
      ancestor name (matches what super(...) actually resolves to via the
      walk-up in ast_infer_type.cpp:5682).

Helper: findChainCtorAncestor (ast_generate.{h,cpp})
    - Shared by lint, gate, and makeConstructor - single source of truth for
      "closest ancestor with a user ctor, skipping empty intermediates."
      Replaces three open-coded for-loops and the unused
      parentHasUserCtor() shim.

Helper methods on Structure
    - Structure::hasUserConstructor() - any non-generated Klass-Klass exists
    - Structure::hasUserDefaultConstructor() - 0-arg-callable user ctor exists
    - Both look up by name hash via the class's own module (ctors are always
      co-located with their class), with a classParent == this identity check
      that defends against same-named classes in other modules (the in-tree
      corpus already has multiple ContextStateAgent classes).

Tests
    - tests/language/super.das: ImplicitChain, two-level MidImplicit/Leaf-
      Implicit (regression for the chain-through-synth-intermediate case
      where the previous straight-Parent-Parent(self) approach failed
      because the synth intermediate has no method form), and
      DerivedWithDefault (chain resolves to parent ctor with default arg).
    - tests/language/failed_parent_no_default.das: B : A where A has only
      def A(int), expect 30322 + 30318/30341 cascade.
    - tests/language/failed_parent_no_default_skip_empty.das: C : B : A
      where B is empty, A has only def A(int). Error 30322 fires for both
      B and C, naming A as the offending ancestor in each.
    - tests/language/failed_super_skip_via_empty_intermediate.das: lint must
      flag C's missing super even though immediate parent B is empty.

Docs
    - doc/source/reference/language/classes.rst: implicit-chain section
      + Option-A suppression note.
    - doc/source/reference/tutorials/18_classes.rst + tutorials/language/
      18_classes.das: implicit-chain example with class Pet : Animal {},
      plus the suppression rule and the parent-no-default error case.

AOT impact
    - Per plan S8: AOT hash for every class that gets a new synth chain
      ctor changes. Expect AOT hash desync on first CI; AOT cache rebuilds
      on next test_aot build.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: borisbat

doc/source/reference/language/classes.rst

@@ -181,6 +181,22 @@ Every constructor in a derived class whose parent has a user-defined constructor
 * two or more ``super(...)`` calls on any path → error;
 * ``super(...)`` inside a loop body → error (call count is not bounded to one).
 
+When the derived class has *no* constructor of its own and the parent has a user
+constructor callable with no arguments (or with all arguments default-initialized), the
+compiler synthesizes a default constructor for the derived class that chains ``super()``
+automatically — so ``new Derived()`` runs the parent's ctor body instead of silently
+skipping it. If the parent's user constructors all require arguments, the derived class
+must declare its own constructor; otherwise compilation fails with
+``missing_super_call``.
+
+Declaring *any* user constructor on a class — even one that only takes arguments —
+suppresses the synthesized 0-arg constructor entirely. ``new Class()`` then requires the
+user to also declare ``def Class()`` explicitly; otherwise lookup fails with
+``no matching function``. This matches the C++/Java/C# convention: a user-defined
+constructor opts out of the compiler-generated default. Pre-PR2 behavior auto-synthesized
+a 0-arg field-init ctor whenever the user omitted one, which silently bypassed any user
+ctor's invariants on ``new Class()`` — that bug is now an error.
+
 Inside a derived class's finalizer (``operator delete``), ``delete super.self`` runs the
 parent's finalizer on the current object:
 

doc/source/reference/tutorials/18_classes.rst

@@ -75,6 +75,47 @@ bypassing virtual dispatch::
 The compiler rewrites ``super()`` to ``Parent`Constructor(self, ...)`` and
 ``super.method()`` to ``Parent`method(self, ...)``.
 
+Implicit ``super()`` chain — no constructor needed
+==================================================
+
+If the parent has a user-defined constructor that's callable with no
+arguments, the compiler synthesizes a default constructor for the derived
+class that chains ``super()`` automatically::
+
+  class Animal {
+      def Animal { print("Animal init\n") }   // 0-arg user ctor
+  }
+
+  class Pet : Animal {
+      name : string = "rex"
+  }
+
+  new Pet()    // prints "Animal init" — synth ctor calls super()
+
+The synthesis runs only when:
+
+- the parent has a user-defined constructor (any signature),
+- the derived class has **no** constructor of its own (none at all), and
+- the parent ctor is 0-arg-callable (no arguments, or all arguments have
+  defaults).
+
+Defining **any** user constructor — even one that only takes arguments —
+suppresses the 0-arg synthesis. ``new Derived()`` then fails to resolve
+unless the user also declares ``def Derived()``::
+
+  class Pet : Animal {
+      def Pet(name : string) { super(); this.name = name }
+  }
+  new Pet()             // ERROR: no matching ctor _::Pet()
+  new Pet("rex")        // OK
+
+If the parent has only constructors that require arguments, the derived
+class must declare its own constructor::
+
+  class A { def A(val : int) { /* ... */ } }
+  class B : A {}                         // ERROR: no 0-arg parent ctor to chain
+  class B : A { def B { super(0) } }     // OK
+
 ``super(...)`` is required exactly once per path
 ================================================
 

include/daScript/ast/ast.h

@@ -288,6 +288,8 @@ namespace das
         string describe() const { return name; }
         string getMangledName() const;
         bool hasAnyInitializers() const;
+        bool hasUserConstructor() const;
+        bool hasUserDefaultConstructor() const;
         void serialize( AstSerializer & ser );
         void gc_collect ( gc_root * target, gc_root * from );
         uint64_t getOwnSemanticHash(HashBuilder & hb,das_set<Structure *> & dep, das_set<Annotation *> & adep) const;

include/daScript/ast/ast_generate.h

@@ -83,6 +83,14 @@ namespace das {
      */
     DAS_API FunctionPtr makeConstructor ( Structure * str, bool isPrivate );
 
+    // Walk `cls`'s inheritance chain starting from cls->parent, return the closest
+    // ancestor with a user-defined ctor (Klass`Klass not generated). Used by the
+    // synth-ctor body emitter (skip past empty intermediates straight to the deepest
+    // user code) and by the lint (super(...) walk-up matches the same target).
+    // Returns nullptr if `cls` isn't a class, has no parent, or no ancestor has a
+    // user ctor.
+    DAS_API Structure * findChainCtorAncestor ( Structure * cls );
+
     /*
      def clone(var a:STRUCT_NAME; b:STRUCT_NAME)
         a.f1 := b.f1

include/daScript/ast/compilation_errors.h

@@ -320,6 +320,7 @@ namespace das
     ,   missing_result                                              =   30319    // 1 site(s)
     ,   missing_structure_field                                     =   30320    // 1 site(s)
     ,   missing_typeinfo_subexpression                              =   30321    // 4 site(s)
+    ,   missing_super_call                                          =   30322    // class ctor must call super(); or parent ctor missing default
 
 // mismatching_*
 

src/ast/ast.cpp

@@ -291,6 +291,57 @@ namespace das {
         return false;
     }
 
+    // True if this structure has any non-generated ctor method (Klass`Klass).
+    // Ctor methods always live in the same module as the class (parser registers
+    // them together), so we look up by name hash via functionsByName / genericsByName.
+    // The `classParent == this` identity check defends against same-named classes
+    // in other modules bleeding in through generic instantiation.
+    bool Structure::hasUserConstructor() const {
+        if ( !module ) return false;
+        string ctorName = name + "`" + name;
+        uint64_t hName = hash64z(ctorName.c_str());
+        if ( auto kv = module->functionsByName.find(hName) ) {
+            for ( auto * fn : kv->second ) {
+                if ( !fn->generated && fn->classParent == this ) return true;
+            }
+        }
+        if ( auto kv = module->genericsByName.find(hName) ) {
+            for ( auto * fn : kv->second ) {
+                if ( !fn->generated && fn->classParent == this ) return true;
+            }
+        }
+        return false;
+    }
+
+    // True if this structure has a non-generated 0-arg-callable ctor (no args, or
+    // all args default-initialized). Used by the synth-derived-ctor gate to verify
+    // the parent has a default constructor reachable as Parent`Parent(self).
+    bool Structure::hasUserDefaultConstructor() const {
+        if ( !module ) return false;
+        string ctorName = name + "`" + name;
+        uint64_t hName = hash64z(ctorName.c_str());
+        auto matches = [this]( Function * fn ) -> bool {
+            if ( fn->generated ) return false;
+            if ( fn->classParent != this ) return false;
+            // arg 0 is always 'self'; arg 1+ must be default-initialized
+            for ( size_t i=1; i<fn->arguments.size(); ++i ) {
+                if ( !fn->arguments[i]->init ) return false;
+            }
+            return true;
+        };
+        if ( auto kv = module->functionsByName.find(hName) ) {
+            for ( auto * fn : kv->second ) {
+                if ( matches(fn) ) return true;
+            }
+        }
+        if ( auto kv = module->genericsByName.find(hName) ) {
+            for ( auto * fn : kv->second ) {
+                if ( matches(fn) ) return true;
+            }
+        }
+        return false;
+    }
+
     bool Structure::canCopy(bool tempMatters) const {
         if ( circularGuard ) return true;
         circularGuard = true;

src/ast/ast_generate.cpp

@@ -292,7 +292,16 @@ namespace das {
         return del;
     }
 
-    // return [[t()]]
+    Structure * findChainCtorAncestor ( Structure * cls ) {
+        if ( !cls || !cls->isClass || !cls->parent ) return nullptr;
+        for ( auto * anc = cls->parent; anc; anc = anc->parent ) {
+            if ( anc->hasUserConstructor() ) return anc;
+        }
+        return nullptr;
+    }
+
+    // return [[t()]] -- or, for a class derived from a parent with a user ctor,
+    // emit the let-self / call Parent`Parent(self) / return self chain body.
     FunctionPtr makeConstructor ( Structure * str, bool isPrivate ) {
         auto fn = new Function();
         fn->generated = true;
@@ -308,21 +317,61 @@ namespace das {
         if ( str->macroInterface ) fn->macroFunction = true;
         auto block = new ExprBlock();
         block->at = str->at;
-        auto makeT = new ExprMakeStruct(str->at);
-        if ( str->isClass ) makeT->alwaysSafe = true;
-        makeT->useInitializer = false;
-        makeT->nativeClassInitializer = true;
-        for ( auto & f : str->fields ) {
-            if ( f.init ) {
-                makeT->useInitializer = true;
-                break;
+        // For synth ctors of derived classes whose ancestor chain has a user ctor,
+        // emit a chain body that calls the deepest USER ctor directly. The synth
+        // walks past intermediate synth-ctored classes since those have no user
+        // code -- only the user ctor's invariants need running.
+        Structure * chainTarget = findChainCtorAncestor(str);
+        if ( chainTarget ) {
+            // let self = [[Derived()]]
+            auto makeT = new ExprMakeStruct(str->at);
+            makeT->alwaysSafe = true;
+            makeT->useInitializer = true;
+            makeT->nativeClassInitializer = true;
+            makeT->makeType = new TypeDecl(str);
+            makeT->structs.push_back(new MakeStruct());
+            auto letS = new ExprLet();
+            letS->at = str->at;
+            letS->atInit = str->at;
+            letS->visibility = str->at;
+            letS->alwaysSafe = true;    // local class variable
+            auto argT = new TypeDecl(str);
+            argT->constant = false;
+            auto argV = new Variable();
+            argV->name = "self";
+            argV->type = argT;
+            argV->at = str->at;
+            argV->generated = true;
+            argV->capture_as_ref = true;
+            argV->init = makeT;
+            argV->init_via_move = true;
+            letS->variables.push_back(argV);
+            block->list.push_back(letS);
+            // call ChainTarget`ChainTarget(self) -- closest ancestor with user ctor
+            auto cll = new ExprCall(str->at, chainTarget->name + "`" + chainTarget->name);
+            cll->arguments.push_back(new ExprVar(str->at, "self"));
+            block->list.push_back(cll);
+            // return self
+            auto returnDecl = new ExprReturn(str->at, new ExprVar(str->at, "self"));
+            returnDecl->moveSemantics = true;
+            block->list.push_back(returnDecl);
+        } else {
+            auto makeT = new ExprMakeStruct(str->at);
+            if ( str->isClass ) makeT->alwaysSafe = true;
+            makeT->useInitializer = false;
+            makeT->nativeClassInitializer = true;
+            for ( auto & f : str->fields ) {
+                if ( f.init ) {
+                    makeT->useInitializer = true;
+                    break;
+                }
             }
+            makeT->makeType = new TypeDecl(str);
+            makeT->structs.push_back(new MakeStruct());
+            auto returnDecl = new ExprReturn(str->at,makeT);
+            returnDecl->moveSemantics = true;
+            block->list.push_back(returnDecl);
         }
-        makeT->makeType = new TypeDecl(str);
-        makeT->structs.push_back(new MakeStruct());
-        auto returnDecl = new ExprReturn(str->at,makeT);
-        returnDecl->moveSemantics = true;
-        block->list.push_back(returnDecl);
         fn->body = block;
         verifyGenerated(fn->body);
         return fn;

src/ast/ast_infer_type.cpp

@@ -401,11 +401,26 @@ namespace das {
     }
     StructurePtr InferTypes::visit(Structure *var) {
         if (!var->genCtor) {
-            if (var->hasAnyInitializers()) {
+            // For a class whose ancestor chain contains a user ctor, synthesize a
+            // default ctor that chains super() to the immediate parent -- otherwise
+            // the user ctor's invariants get silently skipped on new Derived().
+            // findChainCtorAncestor walks past empty intermediates so the chain
+            // reaches the deepest user ctor in one call. Skipped when `var` already
+            // has any user ctor: the user is responsible for chaining via super(...),
+            // and the lint enforces that on every path.
+            Structure * chainTargetAnc = var->hasUserConstructor() ? nullptr : findChainCtorAncestor(var);
+            bool parentNeedsChain = chainTargetAnc != nullptr;
+            bool missingParentDefault = parentNeedsChain && !chainTargetAnc->hasUserDefaultConstructor();
+            if (missingParentDefault) {
+                error("class " + var->name + " inherits from " + chainTargetAnc->name +
+                      " which has no default constructor; provide an explicit def " + var->name + "()", "", "",
+                      var->at, CompilationError::missing_super_call);
+            }
+            if (!missingParentDefault && (var->hasAnyInitializers() || parentNeedsChain)) {
                 if (tryMakeStructureCtor(var, var->privateStructure, false)) {
                     var->genCtor = true;
                 }
-            } else {
+            } else if (!missingParentDefault) {
                 getOrCreateDummy(thisModule);
             }
         }

src/ast/ast_infer_type_helper.cpp

@@ -735,6 +735,15 @@ namespace das {
         return result;
     }
     bool InferTypes::tryMakeStructureCtor(Structure *var, bool isPrivate, bool fromGeneric) {
+        // For classes, defining ANY user ctor (even args-only) suppresses the 0-arg
+        // synth. The pre-PR2 behavior auto-synthesized a 0-arg ctor whenever no 0-arg
+        // user ctor existed, which silently bypassed user invariants for `new Class()`
+        // when only an args-taking user ctor was defined. Matches C++/Java/C# semantics
+        // -- if the user wants `new Class()`, they must write `def Class()` explicitly.
+        // Structs keep the old behavior (no inheritance, no super to bypass).
+        if (var->isClass && var->hasUserConstructor()) {
+            return false;
+        }
         if (!hasDefaultUserConstructor(var->name)) {
             auto ctor = makeConstructor(var, isPrivate);
             if (fromGeneric) {

src/ast/ast_lint.cpp

@@ -317,30 +317,6 @@ namespace das {
         return {lo, hi};
     }
 
-    // True if `klass` has any non-generated user-defined ctor method (Klass`Klass).
-    // A class's ctor methods always live in the same module as the class itself
-    // (parser registers them together), so we jump straight to `klass->module` and
-    // look up by name hash via functionsByName / genericsByName. The `classParent ==
-    // klass` identity check defends against same-named classes in other modules
-    // bleeding in through generic instantiation (the in-tree corpus already has
-    // multiple `ContextStateAgent` classes).
-    bool parentHasUserCtor ( Program *, Structure * klass ) {
-        if ( !klass || !klass->module ) return false;
-        string ctorName = klass->name + "`" + klass->name;
-        uint64_t hName = hash64z(ctorName.c_str());
-        if ( auto kv = klass->module->functionsByName.find(hName) ) {
-            for ( auto * fn : kv->second ) {
-                if ( !fn->generated && fn->classParent == klass ) return true;
-            }
-        }
-        if ( auto kv = klass->module->genericsByName.find(hName) ) {
-            for ( auto * fn : kv->second ) {
-                if ( !fn->generated && fn->classParent == klass ) return true;
-            }
-        }
-        return false;
-    }
-
     bool needAvoidNullPtr ( const TypeDeclPtr & type, bool allowDim ) {
         if ( !type ) {
             return false;
@@ -1060,17 +1036,19 @@ namespace das {
         }
         virtual FunctionPtr visit ( Function * fn ) override {
             // Derived class ctor: every CFG path must call super(...) exactly once,
-            // and only when the parent has a user-defined ctor to chain to.
+            // and only when ANY ancestor has a user-defined ctor to chain to. The
+            // walk-up matches super(...)'s own walk-up semantics — an empty
+            // intermediate (synth chain ctor) propagates the invariant requirement.
             if ( fn->isClassMethod && fn->classParent && fn->classParent->parent
                 && !fn->generated
                 && fn->name == fn->classParent->name + "`" + fn->classParent->name ) {
-                Structure * parent = fn->classParent->parent;
-                if ( parentHasUserCtor(program.get(), parent) ) {
-                    string parentMangled = parent->name + "`" + parent->name;
-                    auto count = reduceSuperCount(countSuperCalls(fn->body, parentMangled));
+                Structure * chainAncestor = findChainCtorAncestor(fn->classParent);
+                if ( chainAncestor ) {
+                    string chainMangled = chainAncestor->name + "`" + chainAncestor->name;
+                    auto count = reduceSuperCount(countSuperCalls(fn->body, chainMangled));
                     if ( count.lo == 0 ) {
                         program->error("class constructor " + fn->name + " does not call super(...) on every control-flow path",
-                            "", "call super(...) (or super." + parent->name + "(...)) exactly once per path",
+                            "", "call super(...) (or super." + chainAncestor->name + "(...)) exactly once per path",
                             fn->at, CompilationError::missing_function_body);
                     } else if ( count.hi != count.lo || count.hi > 1 ) {
                         program->error("class constructor " + fn->name + " calls super(...) more than once on some path",