The F Prime Prime (FPP) Language Specification, Unreleased, after v2.2.0

# Defines an abstract type A
type A
# Defines a struct type B whose member x has type A
struct B {
  x: A
  y: F32
} default { y = 1 }

# Defines an array type A of 3 U8 elements with default value [ 0, 0, 0 ]
array A = [3] U8

# Defines an array type B of 2 A elements with default value
# [ [ 0, 0, 0 ], [ 0, 0, 0 ] ]
array B = [3] A

# Defines an array type C of 3 F32 elements with default value [ 1, 2, 3 ]
array C = [3] F32 default [ 1, 2, 3 ]

# Defines an array type C of 3 U32 values with default value
# [ 1, 1, 1 ] after promoting 1 to [ 1, 1, 1 ]
array D = [3] U32 default 1

# Defines an array type E of 3 U32 values with default value
# [ 1, 1, 1, ] and element format {.03f}
array E = [3] U32 default 1 format "{.03f}"

@ Receives commands from the ground or from a sequencer
@ Dispatches commands to other components
active component CommandDispatcher {

  # ----------------------------------------------------------------------
  # Constants
  # ----------------------------------------------------------------------

  @ The number of com command input ports
  constant numComCmdInPorts = 10

  @ The number of command output ports
  constant numCmdOutPorts = 20

  # ----------------------------------------------------------------------
  # General ports
  # ----------------------------------------------------------------------

  @ Dispatches commands
  output port cmdOut: [numCmdOutPorts] Fw.Cmd

  @ Forwards received command responses
  output port cmdResponseInOut: [numComCmdInPorts] Fw.CmdResponse

  @ Receives com packets containing serialized commands
  async input port comCmdIn: [numComCmdInPorts] Fw.Com

  @ Receives command registration requests
  guarded input port cmdRegIn: [numCmdOutPorts] Fw.CmdReg

  @ Receives command responses
  async input port cmdResponseIn: Fw.CmdResponse

  # ----------------------------------------------------------------------
  # Special ports
  # ----------------------------------------------------------------------

  @ Command receive port
  command recv port cmdIn

  @ Command registration port
  command reg port cmdRegOut

  @ Command response port
  command resp cmdResponseOut

  @ Event port
  event port eventOut

  @ Telemetry port
  telemetry port tlmOut

  @ Text event port
  text event port textEventOut

  @ Time get port
  time get port timeGetOut

  # ----------------------------------------------------------------------
  # Commands
  # ----------------------------------------------------------------------

  @ No-op command
  async command NO_OP

  @ No-op string command
  async command NO_OP_STRING(
      arg1: string size 256 @< The string command argument
  )

  ...

  # ----------------------------------------------------------------------
  # Events
  # ----------------------------------------------------------------------

  @ Opcode registered event
  event OpcodeRegistered(
      regOpcode: Opcode @< The opcode to register
      regPort: U32 @< The registration port
      dispatchSlot: U32 @< The dispatch slot
  ) severity diagnostic \
    format "Opcode {} registered to port {} slot {}"

  @ Opcode dispatched event
  event OpcodeDispatched(
      dispatchOpcode: Opcode @< The opcode dispatched
      dispatchPort: U32 @< The dispatch port
  ) severity command \
    format "Opcode {} dispatched to port {}"

  ...

  # ----------------------------------------------------------------------
  # Telemetry
  # ----------------------------------------------------------------------

  @ Number of commands dispatched
  telemetry CommandsDispatched: U32 update on change

  @ Number of command errors
  telemetry CommandErrors: U32 update on change

}

@ Produces and sends images
active component Imager {

  # ----------------------------------------------------------------------
  # Special ports
  # ----------------------------------------------------------------------

  @ Command receive port
  command recv port cmdIn

  @ Command registration port
  command reg port cmdRegOut

  @ Command response port
  command resp cmdResponseOut

  @ Event port
  event port eventOut

  @ Telemetry port
  telemetry port tlmOut

  @ Text event port
  text event port textEventOut

  @ Time get port
  time get port timeGetOut

  @ Product request port
  product request port productRequestOut

  @ Product receive port
  product recv port productRecvIn

  @ Product send port
  product send port productSendOut

  # ----------------------------------------------------------------------
  # Commands
  # ----------------------------------------------------------------------

  @ Take an image and send it as a data product
  async command TAKE_IMAGE

  ...

  # ----------------------------------------------------------------------
  # Events
  # ----------------------------------------------------------------------

  @ Image taken
  event ImageTaken severity activity low format "Image taken"

  ...

  # ----------------------------------------------------------------------
  # Telemetry
  # ----------------------------------------------------------------------

  @ Number of images taken
  telemetry NumImagesTaken: U32 update on change

  ...

  # ----------------------------------------------------------------------
  # Data products
  # ----------------------------------------------------------------------

  @ A container for images
  product container ImageContainer

  @ A record for holding an image
  product record ImageRecord: Image

}

@ A component with state machines
active component DeviceMgr {

  # ----------------------------------------------------------------------
  # State machines
  # ----------------------------------------------------------------------

  @ A state machine representing a device
  state machine Device {

    @ Start the device
    signal Start

    @ Stop the device
    signal Stop

    @ Initial state is IDLE
    initial enter IDLE

    @ The IDLE state
    state IDLE {
      on Start enter RUNNING
    }

    @ The RUNNING state
    state RUNNING {
      on Stop enter IDLE
    }

  }

  @ State machine instance for device 1
  state machine instance device1: Device

  @ State machine instance for device 2
  state machine instance device2: Device

  # ----------------------------------------------------------------------
  # Special ports
  # ----------------------------------------------------------------------

  ...

  # ----------------------------------------------------------------------
  # Commands
  # ----------------------------------------------------------------------

  @ Send a Start event to the specified device
  async command START(
    @ The device number
    deviceNum: U8
  )

  @ Send a Stop event to the specified device
  async command STOP(
    @ The device number
    deviceNum: U8
  )

}

instance commandDispatcher: Svc.CommandDispatcher \
  base id 0x100 \
  queue size 10 \
  stack size 4096 \
  priority 30 \
  cpu 0

instance timer: Svc.Timer at "../../Timers/HardwareTimer.hpp"

constant a = 0 # a has value 0
constant b = 1.0 # b has value 1.0
constant c = a # c has value 0

enum Gunfighters {
  IL_BUONO
  IL_BRUTTO
  IL_CATTIVO
}

enum U8Gunfighters: U8 {
  IL_BUONO
  IL_BRUTTO
  IL_CATTIVO
}

enum Status {
  YES
  NO
  MAYBE
} default MAYBE

module M {
  constant a = 0
  constant b = a # Inside M, we can refer to M.a as a
  constant c = M.a # We can also say M.a here
}
constant d = M.a # Outside M, we have to say M.a
constant e = a # Error: a is not in scope here

@ Port 1
port Port1(
    a: U32 @< Parameter a
    b: F64 @< Parameter b
)

@ Port 2
port Port2(
    ref a: Fw.Com @< Ref parameter a
)

@ Port 3
port Port3(
    a: U32 @< Parameter a
) -> U32

state machine MonitorSm {

  action doCalibrate
  action init2
  action motorControl
  action reportFault

  guard calibrateReady

  signal Calibrate
  signal Complete
  signal Drive
  signal Fault
  signal RTI
  signal Stop

  initial enter DeviceOn

  state DeviceOn {

    initial do { init2 } enter Initializing

    state Initializing {
      on Complete enter Idle
    }

    state Idle {
      on Drive enter Driving
      on Calibrate if calibrateReady enter Calibrating
    }

    state Calibrating {
      on RTI do { doCalibrate }
      on Fault do { reportFault } enter Idle
      on Complete enter Idle
    }

    state Driving {
      on RTI do { motorControl }
      on Stop enter Idle
    }

  }

}

# Defines a struct type A with members x and y
# and default value { x = 0, y = 0 }
struct A {
  x: U32
  y: F32
}

# Defines a struct type B with members x and y
# and default value { x = 0, y = 1 }
struct B {
  x: U32
  y: F32
} default { y = 1 }

# Defines a struct type C with format specifiers
struct C {
  x: U32 format "{} counts"
  y: F32 format "{} m/s"
}

# Defines a struct type D with member x
# After translation, x is an array of 3 U32 elements
# The associated FPP struct type is { x: U32 }
# The default value of D stores 1 into each of the 3 elements of x
struct D {
  x: [3] U32
} default { x = 1 }

@ Command and data handling topology
topology CDH {

  # ----------------------------------------------------------------------
  # Public instances
  # ----------------------------------------------------------------------

  instance commandDispatcher
  instance commandSequencer
  instance engineeringRateGroup
  instance engineeringTelemetryLogger
  instance engineeringTelemetryConverter
  instance engineeringTelemetrySplitter
  instance eventLogger
  instance rateGroupDriver
  instance telemetryDatabase
  instance timeSource

  # ----------------------------------------------------------------------
  # Private instances
  # ----------------------------------------------------------------------

  private instance socketGroundInterface

  # ----------------------------------------------------------------------
  # Connection patterns
  # ----------------------------------------------------------------------

  command connections instance commandDispatcher
  event connections instance eventLogger
  time connections instance timeSource

  # ----------------------------------------------------------------------
  # Connection graphs
  # ----------------------------------------------------------------------

  connections CommandSequences {
    commandSequencer.comCmdOut -> commandDispatcher.comCmdIn
  }

  connections Downlink {
    eventLogger.comOut -> socketGroundInterface.comEventIn
    telemetryDatabase.comOut -> socketGroundInterface.comTlmIn
  }

  connections EngineeringTelemetry {
    commandDispatcher.tlmOut -> engineeringTelemetrySplitter.tlmIn
    commandSequencer.tlmOut -> telemetryDatabase.tlmIn
    engineeringRateGroup.tlmOut -> engineeringTelemetrySplitter.tlmIn
    engineeringTelmetryConverter.comTlmOut -> engineeringTelemetryLogger.comTlmIn
    engineeringTelemetrySplitter.tlmOut -> engineeringTelemetryConverter.tlmIn
    engineeringTelemetrySplitter.tlmOut -> telemetryDatabase.tlmIn
  }

  connections RateGroups {
    engineeringRateGroup.schedOut -> commandSequencer.schedIn
    engineeringRateGroup.schedOut -> telemetryDatabase.schedIn
    rateGroupDriver.cycleOut -> engineeringRateGroup.cycleIn
  }

  connections Uplink {
    socketGroundInterface.comCmdOut -> commandDispatcher.comCmdIn
  }

}

@ Attitude control topology
topology AttitudeControl {

  # ----------------------------------------------------------------------
  # Imported topologies
  # ----------------------------------------------------------------------

  import CDH

  # ----------------------------------------------------------------------
  # Public instances
  # ----------------------------------------------------------------------

  instance acsRateGroup
  instance attitudeControl
  ...

  # ----------------------------------------------------------------------
  # Private instances
  # ----------------------------------------------------------------------

  instance socketGroundInterface

  # ----------------------------------------------------------------------
  # Connection patterns
  # ----------------------------------------------------------------------

  command connections instance commandDispatcher
  event connections instance eventLogger
  time connections instance timeSource


  # ----------------------------------------------------------------------
  # Connection graphs
  # ----------------------------------------------------------------------

  connections AttitudeTelemetry {
    ...
  }

  connections Downlink {
    eventLogger.comOut -> socketGroundInterface.comEventIn
    telemetryDatabase.comOut -> socketGroundInterface.comTlmIn
  }

  connections EngineeringTelemetry {
    acsRateGroup.tlmOut -> engineeringTelemetrySplitter.tlmIn
    ...
  }

  connections RateGroups {
    acsRateGroup.schedOut -> attitudeControl.schedIn
  }

  connections Uplink {
    socketGroundInterface.comCmdOut -> commandDispatcher.comCmdIn
  }

}

@ Release topology
topology Release {

  # ----------------------------------------------------------------------
  # Imported topologies
  # ----------------------------------------------------------------------

  import AttitudeControl
  import CDH
  import Communication
  ...

}

topology B {

  instance a
  instance c
  instance d
  instance e
  instance f

  connections C1 {
    a.p1[0] -> c.p[0]
    a.p1[1] -> d.p[0]
  }

  connections C2 {
    a.p2[0] -> e.p[0]
  }

  connections C3 {
    a.p3[0] -> f.p[0]
  }

}

struct FaultData {
  $id: U32
  data: U32
}

@ A state machine with action definitions
state machine ActionDefs {

  @ An action without data
  action initPower

  @ An action with data
  action reportFault: FaultData

  ...

}

state machine Device {

  action powerActuator
  action powerGyro
  action powerGimbal

  state ON {
    entry do {
      powerActuator
      powerGyro
      powerGimbal
    }
  }

}

enum EnabledStatus { ENABLED, DISABLED }

struct FaultData {
  status: EnabledStatus
  $id: U32
  data: U32
}

@ A state machine with guard definitions
state machine GuardDefs {

  @ A guard without data
  guard powerIsEnabled

  @ A guard with data
  guard faultProtectionIsEnabled: FaultData

  ...

}

state machine Device {

  action initDev1
  action initDev2

  # When the state machine starts up, enter the ON state
  initial enter ON

  state ON {

    # When entering the ON state, enter the POWERING_UP substate
    initial do {
      initDev1
      initDev2
    } \
    enter POWERING_UP

    state POWERING_UP

  }

}

state machine Device {

  action initPower
  guard coldStart

  initial enter J1

  junction J1 {
    if coldStart enter OFF \
    else do { initPower } enter ON
  }

  state OFF

  state ON

}

struct FaultData {
  $id: U32
  data: U32
}

@ A state machine with signal definitions
state machine SignalDefs {

  @ A signal without data
  signal RTI

  @ A signal with data
  signal Fault: FaultData

  ...

}

state machine MonitorSm {

  action doCalibrate
  action heaterOff
  action heaterOn
  action init1
  action init2
  action monitorOff
  action monitorOn
  action motorControl
  action reportFault
  action stopMotor

  guard calibrateReady

  signal Calibrate
  signal Complete
  signal Drive
  signal Fault
  signal RTI
  signal Stop

  initial enter DEVICE_ON

  state DEVICE_ON {

    initial do {
      init1
      init2
     } \
     enter INITIALIZING

    state INITIALIZING {
      on Complete enter IDLE
    }

    state IDLE {
      entry do {
        heaterOff
        monitorOff
      }
      exit do {
        heaterOn
        monitorOn
      }
      on Drive enter DRIVING
      on Calibrate if calibrateReady enter CALIBRATING
    }

    state CALIBRATING {
      on RTI do { doCalibrate }
      on Fault do { reportFault } enter Idle
      on Complete enter IDLE
    }

    state DRIVING {
      on RTI do { motorControl }
      on Stop do { stopMotor } enter IDLE
    }

  }

}

state machine Device {

  action heaterOn
  action monitorOn

  state RUNNING {
    entry do {
      heaterOn
      monitorOn
    }

  }

}

state machine Device {

  action heaterOff
  action monitorOff

  state RUNNING {
    exit do {
      heaterOff
      monitorOff
    }

  }

}

state machine Device {

  action performStuff
  action powerHeater
  action powerSensor

  guard initComplete

  signal PowerOn
  signal RTI

  initial enter OFF

  state OFF {
    on PowerOn if initComplete do {
      powerHeater
      powerSensor
    } \
    enter ON
  }

  state ON {
    on RTI do { performStuff }
  }

}

state machine Device {

  action initDev1
  action initDev2

  initial do {
    initDev1
    initDev2
  } \
  enter OFF

  state OFF

}

@ A sync command with no parameters
sync command SyncNoParams opcode 0x00

@ An async command with no parameters
async command AsyncNoParams opcode 0x01

@ A sync command with parameters
sync command SyncParams(
    param1: U32 @< Param 1
    param2: string @< Param 2
) opcode 0x02

@ An async command with parameters
async command AsyncParams(
    param1: U32 @< Param 1
    param2: string @< Param 2
) opcode 0x03

@ An async command with priority
async command AsyncPriority(
    param1: U32 @< Param 1
    param2: string @< Param 2
) opcode 0x04 priority 10

@ An async command with priority and drop on queue full
async command AsyncPriorityDrop(
    param1: U32 @< Param 1
    param2: string @< Param 2
) opcode 0x05 priority 10 drop

component A { ... }
component B { ... }
component C { ... }

instance a: A base id 0x100 ...
instance b: B base id 0x200 ...
instance c: B base id 0x300 ...

Topology T {

  # ----------------------------------------------------------------------
  # Public instances
  # ----------------------------------------------------------------------

  instance a
  instance b

  # ----------------------------------------------------------------------
  # Private instances
  # ----------------------------------------------------------------------

  private instance c

  ...

}

commandDispatcher
commandSequencer
engineeringTelemetryLogger
eventLogger
telemetryDatabase
timeSource

command connections instance commandDispatcher

connections CommandRegistration {
  commandDispatcher.cmdRegOut -> commandDispatcher.cmdRegIn
  commandSequencer.cmdRegOut -> commandDispatcher.cmdRegIn
  engineeringTelemetryLogger.cmdRegOut -> commandDispatcher.cmdRegIn
  eventLogger.cmdRegOut -> commandDispatcher.cmdRegIn
  telemetryDatabase.cmdRegOut -> commandDispatcher.cmdRegIn
  timeSource.cmdRegOut -> commandDispatcher.cmdRegIn
}

connections Command {
  commandDispatcher.cmdOut -> commandDispatcher.cmdIn
  commandDispatcher.cmdOut -> commandSequencer.cmdIn
  commandDispatcher.cmdOut -> engineeringTelemetryLogger.cmdIn
  commandDispatcher.cmdOut -> eventLogger.cmdIn
  commandDispatcher.cmdOut -> telemetryDatabase.cmdIn
  commandDispatcher.cmdOut -> timeSource.cmdIn
}

connections CommandResponse {
  commandDispatcher.cmdRespOut -> commandDispatcher.cmdRespIn
  commandSequencer.cmdRespOut -> commandDispatcher.cmdRespIn
  engineeringTelemetryLogger.cmdRespOut -> commandDispatcher.cmdRespIn
  eventLogger.cmdRespOut -> commandDispatcher.cmdRespIn
  telemetryDatabase.cmdRespOut -> commandDispatcher.cmdRespIn
  timeSource.cmdRespOut -> commandDispatcher.cmdRespIn
}

@ Container 0
@ Implied id is 0x00
product container Container0

@ Container 1
product container Container1 id 0x02

@ Container 2
@ Implied id is 0x03
product container Container2 default priority 10

@ An array of 3 F64 values
array F64x3 = [3] F64

@ An enumeration of cases
enum Case { A, B, C }

@ Event 0
event Event0 \
  severity activity low \
  id 0x00 \
  format "Event 0 occurred"

@ Event 1
@ Sample output: "Event 1 occurred with argument 42"
event Event1(
  arg1: U32 @< Argument 1
) \
  severity activity high \
  id 0x01 \
  format "Event 1 occurred with argument {}"

@ Event 2
@ Sample output: "Saw value [ 0.001, 0.002, 0.003 ] for case A"
event Event2(
  case: Case @< The case
  value: F64x3 @< The value
) \
  severity warning low \
  id 0x02 \
  format "Saw value {} for case {}" \
  throttle 10

constant a = 1

include "a.fppi"
constant b = a

constant a = 1
constant b = a

constant a = 1

module M { include "a.fppi" }
b = M.a

module M { constant a = 1 }
b = M.a

@ Phases of initialization
enum Phases {
  @ When components are constructed
  CONSTRUCTION
  @ After components are constructed, and before connections are established
  BEFORE_CONNECTIONS
  @ After connections are established
  AFTER_CONNECTIONS
  @ When components are deallocated
  TEARDOWN
}

instance commandDispatcher: Svc.CommandDispatcher \
  base id 0x100 \
  queue size 10 \
  stack size 4096 \
  priority 30 \
{

  phase BEFORE_CONNECTIONS  """
  commandDispatcher.init(QueueDepth::commandDispatcher);
  """

}

Svc::CommandDispatcher commandDispatcher("commandDispatcher");

commandDispatcher.init(
    QueueDepth::commandDispatcher,
    InstanceID::commandDispatcher
);

@ Port 1
internal port Port1(
    a: U32 @< Parameter a
    b: F64 @< Parameter b
)

@ Port 2
internal port Port2(
    a: U8 @< Parameter a
    b: I32 @< Parameter b
) priority 10 drop

constant a = 1

locate constant a at "a.fpp"
constant b = a

module M { constant b = 0 }

locate constant a at "a.fpp"
module M { locate constant b at "b.fpp" }

@ Parameter 1
param Parameter1: U32 \
  id 0x00 \
  set opcode 0x80 \
  save opcode 0x81

@ Parameter 2
param Parameter2: F64 \
  default 1.0 \
  id 0x01 \
  set opcode 0x82 \
  save opcode 0x83

@ Async input port of type Fw.Com
@ It has priority 10.
@ It drops input received when the queue is full.
async input port asyncComIn: Fw.Com priority 10 drop

@ Async input serial port
async input port serialIn: serial

@ Guarded input port of type Fw.Com
guarded input port guardedComIn: Fw.Com

@ Output port array of 10 Fw.Com ports
output port comOut: [10] Fw.Com

@ Sync input port of type Fw.Com
sync input port syncComIn: Fw.Com

@ A port for receiving commands from the command dispatcher
command recv port cmdIn

@ A port for sending command registration requests to the command dispatcher
command reg port cmdRegOut

@ A port for sending responses to the command dispatcher
command resp port cmdRespOut

@ A port for emitting events
event port eventOut

@ A port for emitting text events
text event port textEventOut

@ A port for getting parameter values from the parameter database
param get port paramGetOut

@ A port for sending parameter values to the parameter database
param set port paramSetOut

@ A port for emitting telemetry channels
telemetry port tlmOut

@ A port for getting the current time
time get port timeGetOut

@ An async port for receiving requested data product buffers
async product recv port productRecvIn

@ A port for requesting data product buffers
product request port productRequestOut

@ A port for sending data products
product send port productSendOut

queued component Health {

  @ Number of ping ports
  constant numPingPorts = 10

  @ Ping output port
  output port pingOut: [numPingPorts] Svc.Ping

  @ Ping input port
  async input port pingIn: [numPingPorts] Svc.Ping

  @ Corresponding port numbers of pingOut and pingIn must match
  match pingOut with pingIn

}

@ An array of 3 F64 values
array F64x3 = [3] F64

@ Record 0: A variable number of F32 values
@ Implied id is 0x00
product record Record0: F32 array

@ Record 1: A single U32 value
product record Record1: U32 id 0x02

@ Record 2: A single F64x3 value
@ Implied id is 0x03
product record Record2: F64x3

state machine M {
  initial S
  state S
}

passive component C {

  @ m1 is an instance of state machine M
  state machine instance m1: M

  @ m2 is an instance of state machine M
  state machine instance m2: M priority 10 drop

}

@ An array of 3 F64 values
array F64x3 = [3] F64

@ Telemetry channel 0
telemetry Channel0: U32 id 0x00

@ Telemetry channel 1
telemetry Channel1: U32 \
  id 0x01 \
  update on change

@ Telemetry channel 2
telemetry Channel2: F64 \
  id 0x02 \
  format "{.3f}"

@ Telemetry channel 3
telemetry Channel3: F64x3 \
  id 0x03 \
  low { yellow -1, orange -2, red -3 } \
  high { yellow 1, orange 2, red 3 }

topology A {

  instance a
  private instance b
  instance c

  connections C1 {
    a.p1 -> c.p
  }

  connections C2 {
    b.p -> c.p
  }

}

topology B {

  import A

  instance d
  instance e
  instance f

  connections C1 {
    a.p1 -> d.p
  }

  connections C2 {
    a.p2 -> e.p
  }

  connections C3 {
    a.p3 -> f.p
  }

}

topology B {

  instance a
  instance c
  instance d
  instance e
  instance f

  connections C1 {
    a.p1 -> c.p
    a.p2 -> d.p
  }

  connections C2 {
    a.p2 -> e.p
  }

  connections C3 {
    a.p3 -> f.p
  }

}

constant a = [ 0, 1, 2 ] # a is an array value with elements 0, 1, 2

constant a = (1 + 2) * 3

constant s = """\"\"\""""

  """
  // This is a multiline string literal
  // It represents some C++ code
  instance.create(0, 1);
  """

# s is a struct value with members x = 0, y = 1
constant s = {
  x = 0
  y = 1
}

module M1 { constant a = 0 }

module M1 { constant b = 0 }

module M2 {
  constant a = M1.a
  constant b = M1.b
}

struct s { x: U32 } # Defines s in the type name group
constant s = 0 # Defines s in the value name group

module M { constant a = 0 }
module M { constant b = 1 }
a = M.a
b = M.b

module M {
  constant a = 0
  constant b = 1
}
a = M.a
b = M.b

module M { constant a = 0 }
a = M.a
b = M.b
module M { constant b = 1 }

module M {
  constant a = 0
  constant a = 1 # Error: Name M.a is redefined
}

constant a = 0
module M {
  constant a = 1 # OK, qualified name is M.a =/= a
}