anchor.diff:  
           let entRef = decl.Entity
           let ent = com.GetEntity(entRef)
  -        let entNamesp, entName = splitNameSpace ent.FullName
  +        let entNameSpace, entName = splitNameSpace ent.FullName
   
           let ctx = { ctx with ScopedTypeParams =
                                   ent.GenericParameters
                                   |> List.map (fun g -> g.Name)
                                   |> Set.ofList }
   
  -        let ctorImpls =
  -            if ent.IsFSharpUnion || ent.IsFSharpRecord then
  -                []
  -            else
  -                let primaryCtorItem =
  -                    match decl.Constructor with
  -                    | Some ctor ->
  -                        withCurrentScope ctx ctor.UsedNames <| fun ctx ->
  -                            transformImplicitConstructor com ctx ent ctor
  -                    | _ ->
  -                        transformCompilerGeneratedConstructor com ctx ent decl.Name
  -                    |> mkPublicAssocItem
  -                let ctorItems =
  -                    decl.AttachedMembers
  -                    |> List.filter isConstructor
  -                    |> List.map (makeMemberItem ctx)
  -                let ctorItems = primaryCtorItem :: ctorItems
  -                let genArgs = getEntityGenArgs ent
  -                let ty = transformDeclaredType com ctx entRef genArgs
  -                let generics = genArgs |> makeGenerics com ctx
  -                let implItem = mkImplItem [] "" ty generics ctorItems None
  -                [implItem]
  +        let ctorOrStaticImpls =
  +            let ctorItems =
  +                if ent.IsFSharpUnion || ent.IsFSharpRecord then
  +                    []
  +                else
  +                    let ctorItem =
  +                        match decl.Constructor with
  +                        | Some ctor ->
  +                            withCurrentScope ctx ctor.UsedNames <| fun ctx ->
  +                                transformImplicitConstructor com ctx ent ctor
  +                        | _ ->
  +                            transformCompilerGeneratedConstructor com ctx ent decl.Name
  +                    [ctorItem |> mkPublicAssocItem]
  +            let ctorOrStaticItems =
  +                decl.AttachedMembers
  +                |> List.filter isConstructorOrStatic
  +                |> List.map (makeMemberItem ctx)
  +                |> List.append ctorItems
  +            let genArgs = getEntityGenArgs ent
  +            let ty = transformDeclaredType com ctx entRef genArgs
  +            let generics = genArgs |> makeGenerics com ctx
  +            let implItem = mkImplItem [] "" ty generics ctorOrStaticItems None
  +            [implItem]
   
           let interfaces =
               ent.AllInterfaces
  
positive.code:                         mkGenericPath nameParts (mkGenericTypeArgs genArgTys)
                      let ofTrait = mkTraitRef path |> Some
                      mkImplItem [] "" ty generics memberItems ofTrait
                  [
                      if memberItemsStatic |> List.isEmpty |> not then
                          yield implItemStatic
                      if memberItems |> List.isEmpty |> not then
                          yield implItem
                      ]
              )
  
          ctorImpls @ nonInterfaceMembersTrait @ memberTraitImpls
  
      let transformClassDecl (com: IRustCompiler) ctx (decl: Fable.ClassDecl) =
          let ent = com.GetEntity(decl.Entity)
  
negative.code:         [tyItem]
  
      let transformUnion (com: IRustCompiler) ctx (ent: Fable.Entity) =
          let entNameSpace, entName = splitNameSpace ent.FullName
          let generics = getEntityGenArgs ent |> makeGenerics com ctx
          let variants =
              ent.UnionCases |> Seq.map (fun uci ->
  