Allow for top-level variables

[RestartFU]

Hello, I was wondering why there's no support for top level variables, is it intentionally forbidden?

I have a case where this could be useful:

import "go:github.com/df-mc/dragonfly/server/block/cube"
 import "go:github.com/df-mc/dragonfly/server/entity"
 import "go:github.com/df-mc/dragonfly/server/world"
 import "go:github.com/df-mc/dragonfly/server/world/particle"
+var snowball_conf = entity.ProjectileBehaviourConfig {
+  Gravity: 0.03,
+  Drag: 0.01,
+  Particle: Some(particle.SnowballPoof {}),
+  ParticleCount: 6,
+  ..,
+}
 struct SwitcherBallType {}
 pub fn new_snowball(opts: world.EntitySpawnOpts, owner: world.Entity) -> Ref<world.EntityHandle> {
-  let conf = entity.ProjectileBehaviourConfig { 
-    Gravity: 0.03,
-    Drag: 0.01,
-    Particle: Some(particle.SnowballPoof {}),
-    ParticleCount: 6,
-    Owner: owner.H(),
-    ..,
-  }
-  opts.New(None, conf)
+  let mut conf = snowball_conf
+  conf.Owner = owner.H()
+  opts.New(None, conf)
 }
 impl SwitcherBallType {
   fn Open(
     self,
     tx: Ref<world.Tx>,
     handle: Ref<world.EntityHandle>,
     data: Ref<world.EntityData>,
   ) -> world.Entity {
     entity.Open(tx, handle, data)
   }
   fn EncodeEntity(self) -> string {
     "minecrcaft:snowball"
   }
   fn BBox(self, _: world.Entity) -> cube.BBox {
     cube.Box(-0.125, 0, -0.125, 0.125, 0.25, 0.125)
   }
   fn EncodeNBT(self, _: Ref<world.EntityData>) -> Map<string, Unknown> {
     Map.new()
   }
   fn DecodeNBT(self, _: Map<string, Unknown>, data: Ref<world.EntityData>) {
-    data.Data = entity.ProjectileBehaviourConfig { 
-      Gravity: 0.03,
-      Drag: 0.01,
-      Particle: Some(particle.SnowballPoof {}),
-      ParticleCount: 6,
-      ..,
-    }
+    data.Data = snowball_conf
   }
 }

[ivov]

Hi @RestartFU

This is intentional, but the error is confusing. I'll add a diagnostic to make this clearer.

Lisette expresses this pattern as a function, to make the copy explicit via value semantics. Go has no immutable composite globals to lower onto (in Go const is for primitives only) and a mutable package-level var template would be one stray write away from corrupting every snowball across goroutines.

fn snowball_conf() -> entity.ProjectileBehaviourConfig {
  entity.ProjectileBehaviourConfig {
    Gravity: 0.03,
    Drag: 0.01,
    Particle: Some(particle.SnowballPoof {}),
    ParticleCount: 6,
    ..,
  }
}

struct SwitcherBallType {}

pub fn new_snowball(opts: world.EntitySpawnOpts, owner: world.Entity) -> Ref<world.EntityHandle> {
  let conf = entity.ProjectileBehaviourConfig { Owner: owner.H(), ..snowball_conf() }
  opts.New(None, conf)
}

impl SwitcherBallType {
  fn DecodeNBT(self, _: Map<string, Unknown>, data: Ref<world.EntityData>) {
    data.Data = snowball_conf()
  }
}