shishantbiswas/c3c
1
1
Fork 0
mirror of https://github.com/c3lang/c3c.git synced 2026-02-27 03:51:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update to constdef

Browse Source
This commit is contained in:
Christoffer Lerno
2026-02-19 12:16:46 +01:00
committed by Christoffer Lerno
parent 0387d7666d
commit 5a82f672b5
52 changed files with 189 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
lib/std/compression/qoi.c3
View File

@@ -7,7 +7,7 @@ const uint PIXELS_MAX = 400000000;
Purely informative. It will be saved to the file header, Purely informative. It will be saved to the file header,
but does not affect how chunks are en-/decoded. but does not affect how chunks are en-/decoded.
*> *>
const enum QOIColorspace : char constdef QOIColorspace : char
{ {
<* sRGB with linear alpha *> <* sRGB with linear alpha *>
SRGB = 0, SRGB = 0,
@@ -21,7 +21,7 @@ const enum QOIColorspace : char
AUTO can be used when decoding to automatically determine AUTO can be used when decoding to automatically determine
the channels from the file's header. the channels from the file's header.
*> *>
const enum QOIChannels : inline char constdef QOIChannels : inline char
{ {
AUTO = 0, AUTO = 0,
RGB = 3, RGB = 3,

2
lib/std/core/ansi.c3
View File

@@ -1,7 +1,7 @@
module std::core::string::ansi; module std::core::string::ansi;
import std::io; import std::io;
const enum Ansi : inline String constdef Ansi : inline String
{ {
RESET = "\e[0m", RESET = "\e[0m",
BOLD = "\e[1m", BOLD = "\e[1m",

2
lib/std/hash/blake3.c3
View File

@@ -91,7 +91,7 @@ macro @simd_degree() @local
} }
<* Flags used during hash computation based on its state. *> <* Flags used during hash computation based on its state. *>
const enum Blake3Flags : inline char constdef Blake3Flags : inline char
{ {
CHUNK_START = 1 << 0, CHUNK_START = 1 << 0,
CHUNK_END = 1 << 1, CHUNK_END = 1 << 1,

2
lib/std/hash/gost/streebog.c3
View File

@@ -8,7 +8,7 @@
module std::hash::streebog; module std::hash::streebog;
const enum StreebogLength : inline uint constdef StreebogLength : inline uint
{ {
SIZE_256 = 32, SIZE_256 = 32,
SIZE_512 = 64, SIZE_512 = 64,

20
lib/std/libc/os/posix.c3
View File

@@ -168,13 +168,13 @@ bitstruct Tc_lflags : CUInt
bool extproc : 16; bool extproc : 16;
} }
const enum T_nldly : char constdef T_nldly : char
{ {
NL0 = 0b0, NL0 = 0b0,
NL1 = 0b1, NL1 = 0b1,
} }
const enum T_crdly : char constdef T_crdly : char
{ {
CR0 = 0b00, CR0 = 0b00,
CR1 = 0b01, CR1 = 0b01,
@@ -182,7 +182,7 @@ const enum T_crdly : char
CR3 = 0b11, CR3 = 0b11,
} }
const enum T_tabdly : char constdef T_tabdly : char
{ {
TAB0 = 0b00, TAB0 = 0b00,
TAB1 = 0b01, TAB1 = 0b01,
@@ -191,25 +191,25 @@ const enum T_tabdly : char
XTABS = TAB3, XTABS = TAB3,
} }
const enum T_bsdly : char constdef T_bsdly : char
{ {
BS0 = 0b0, BS0 = 0b0,
BS1 = 0b1, BS1 = 0b1,
} }
const enum T_ffdly : char constdef T_ffdly : char
{ {
FF0 = 0b0, FF0 = 0b0,
FF1 = 0b1, FF1 = 0b1,
} }
const enum T_vtdly : char constdef T_vtdly : char
{ {
VT0 = 0b0, VT0 = 0b0,
VT1 = 0b1, VT1 = 0b1,
} }
const enum T_csize : char constdef T_csize : char
{ {
CS5 = 0b00, CS5 = 0b00,
CS6 = 0b01, CS6 = 0b01,
@@ -217,7 +217,7 @@ const enum T_csize : char
CS8 = 0b11, CS8 = 0b11,
} }
const enum Speed : CUInt constdef Speed : CUInt
{ {
B0 = 0o0000000, B0 = 0o0000000,
B50 = 0o0000001, B50 = 0o0000001,
@@ -253,7 +253,7 @@ const enum Speed : CUInt
MAX_BAUD = B4000000, MAX_BAUD = B4000000,
} }
const enum Cc : inline char constdef Cc : inline char
{ {
VINTR = 0, VINTR = 0,
VQUIT = 1, VQUIT = 1,
@@ -274,7 +274,7 @@ const enum Cc : inline char
VEOL2 = 16, VEOL2 = 16,
} }
const enum Tcactions : CInt constdef Tcactions : CInt
{ {
TCOOFF = 0, TCOOFF = 0,
TCOON = 1, TCOON = 1,

4
lib/std/net/socket.c3
View File

@@ -25,7 +25,7 @@ macro void @loop_over_ai(AddrInfo* ai; @body(NativeSocket fd, AddrInfo* ai))
const Duration POLL_FOREVER = (Duration)-1; const Duration POLL_FOREVER = (Duration)-1;
const enum PollSubscribe constdef PollSubscribe
{ {
ANY_READ = os::POLLIN, ANY_READ = os::POLLIN,
PRIO_READ = os::POLLPRI, PRIO_READ = os::POLLPRI,
@@ -44,7 +44,7 @@ const PollSubscribe SUBSCRIBE_ANY_WRITE = (PollSubscribe)os::POLLOUT;
const PollSubscribe SUBSCRIBE_OOB_WRITE = (PollSubscribe)os::POLLWRBAND; const PollSubscribe SUBSCRIBE_OOB_WRITE = (PollSubscribe)os::POLLWRBAND;
const PollSubscribe SUBSCRIBE_WRITE = (PollSubscribe)os::POLLWRNORM; const PollSubscribe SUBSCRIBE_WRITE = (PollSubscribe)os::POLLWRNORM;
const enum PollEvent : ushort constdef PollEvent : ushort
{ {
READ_PRIO = os::POLLPRI, READ_PRIO = os::POLLPRI,
READ_OOB = os::POLLRDBAND, READ_OOB = os::POLLRDBAND,

2
lib/std/os/linux/epoll.c3
View File

@@ -18,7 +18,7 @@ const uint EPOLLWAKEUP = EpollEvents.EPOLLWAKEUP;
const uint EPOLLONESHOT = EpollEvents.EPOLLONESHOT; const uint EPOLLONESHOT = EpollEvents.EPOLLONESHOT;
const uint EPOLLET = EpollEvents.EPOLLET; const uint EPOLLET = EpollEvents.EPOLLET;
const enum EpollEvents : inline uint constdef EpollEvents : inline uint
{ {
EPOLLIN = 0x001, EPOLLIN = 0x001,
EPOLLPRI = 0x002, EPOLLPRI = 0x002,

2
lib/std/os/macos/core_foundation.c3
View File

@@ -40,7 +40,7 @@ extern fn CFTypeRef CFType.retain(&self) @cname("CFRetain");
extern fn void CFType.release(&self) @cname("CFRelease"); extern fn void CFType.release(&self) @cname("CFRelease");
extern fn CFIndex CFType.getRetainCount(&self) @cname("CFGetRetainCount"); extern fn CFIndex CFType.getRetainCount(&self) @cname("CFGetRetainCount");
const enum CFStringEncoding : uint constdef CFStringEncoding : uint
{ {
INVALID_ID = 0xffffffffU, INVALID_ID = 0xffffffffU,
MAC_ROMAN = 0, MAC_ROMAN = 0,

4
lib/std/os/macos/general.c3
View File

@@ -1,7 +1,7 @@
module std::os::darwin @if(env::DARWIN) @link("Foundation.framework"); module std::os::darwin @if(env::DARWIN) @link("Foundation.framework");
import std::os::macos::cf, std::os::macos::objc, std::io; import std::os::macos::cf, std::os::macos::objc, std::io;
const enum NSSearchPathDomainMask : NSUInteger constdef NSSearchPathDomainMask : NSUInteger
{ {
USER = 1, USER = 1,
LOCAL = 2, LOCAL = 2,
@@ -10,7 +10,7 @@ const enum NSSearchPathDomainMask : NSUInteger
ALL = 0x0ffff ALL = 0x0ffff
} }
const enum NSSearchPathDirectory : NSUInteger constdef NSSearchPathDirectory : NSUInteger
{ {
APPLICATION = 1, APPLICATION = 1,
DEMO_APPLICATION, DEMO_APPLICATION,

22
lib/std/os/macos/objc.c3
View File

@@ -88,7 +88,7 @@ enum ApplicationActivationPolicy : (int val) @deprecated("Use NSApplicationActiv
PROHIBITED { 2 }, PROHIBITED { 2 },
} }
const enum NSApplicationActivationPolicy : inline NSInteger constdef NSApplicationActivationPolicy : inline NSInteger
{ {
REGULAR = 0, REGULAR = 0,
ACCESSORY = 1, ACCESSORY = 1,
@@ -119,7 +119,7 @@ enum BackingStore : (int val) @deprecated("Use NSBackingStoreType.")
BUFFERED { 2 } BUFFERED { 2 }
} }
const enum NSBackingStoreType : inline NSUInteger constdef NSBackingStoreType : inline NSUInteger
{ {
RETAINED = 0, RETAINED = 0,
NONRETAINED = 1, NONRETAINED = 1,
@@ -164,7 +164,7 @@ enum EventType : (long val) @deprecated("Use NSEventType.")
CHANGE_MODE { 38 }, CHANGE_MODE { 38 },
} }
const enum NSEventType : inline NSUInteger constdef NSEventType : inline NSUInteger
{ {
LEFT_MOUSE_DOWN = 1, LEFT_MOUSE_DOWN = 1,
LEFT_MOUSE_UP = 2, LEFT_MOUSE_UP = 2,
@@ -280,7 +280,7 @@ enum EventMask : (long val) @deprecated("Use NSEventMask.")
ANY { long.max }, ANY { long.max },
} }
const enum NSEventMask : inline ulong constdef NSEventMask : inline ulong
{ {
LEFT_MOUSE_DOWN = 1ul << NSEventType.LEFT_MOUSE_DOWN, LEFT_MOUSE_DOWN = 1ul << NSEventType.LEFT_MOUSE_DOWN,
LEFT_MOUSE_UP = 1ul << NSEventType.LEFT_MOUSE_UP, LEFT_MOUSE_UP = 1ul << NSEventType.LEFT_MOUSE_UP,
@@ -333,7 +333,7 @@ enum EventModifierFlag : (int val) @deprecated("Use NSEventModifierFlags.")
HELP { 1 << 22 }, HELP { 1 << 22 },
} }
const enum NSEventModifierFlags : inline NSUInteger constdef NSEventModifierFlags : inline NSUInteger
{ {
CAPS_LOCK = 1 << 16, CAPS_LOCK = 1 << 16,
SHIFT = 1 << 17, SHIFT = 1 << 17,
@@ -346,7 +346,7 @@ const enum NSEventModifierFlags : inline NSUInteger
DEVICE_INDEPENDENT_FLAGS_MASK = 0xffff0000UL, DEVICE_INDEPENDENT_FLAGS_MASK = 0xffff0000UL,
} }
const enum NSWindowCollectionBehavior : inline NSUInteger constdef NSWindowCollectionBehavior : inline NSUInteger
{ {
DEFAULT = 0, DEFAULT = 0,
CAN_JOIN_ALL_SPACES = 1 << 0, CAN_JOIN_ALL_SPACES = 1 << 0,
@@ -366,7 +366,7 @@ const enum NSWindowCollectionBehavior : inline NSUInteger
CAN_JOIN_ALL_APPLICATIONS = 1 << 18, CAN_JOIN_ALL_APPLICATIONS = 1 << 18,
} }
const enum NSWindowLevel : inline NSInteger constdef NSWindowLevel : inline NSInteger
{ {
NORMAL = 0, NORMAL = 0,
FLOATING = 3, FLOATING = 3,
@@ -379,7 +379,7 @@ const enum NSWindowLevel : inline NSInteger
SCREEN_SAVER = 1000, SCREEN_SAVER = 1000,
} }
const enum NSWindowStyleMask : inline NSUInteger constdef NSWindowStyleMask : inline NSUInteger
{ {
BORDERLESS = 0, BORDERLESS = 0,
TITLED = 1 << 0, TITLED = 1 << 0,
@@ -396,20 +396,20 @@ const enum NSWindowStyleMask : inline NSUInteger
HUD_WINDOW = 1 << 13 HUD_WINDOW = 1 << 13
} }
const enum NSWindowTabbingMode : inline NSInteger constdef NSWindowTabbingMode : inline NSInteger
{ {
AUTOMATIC = 0, AUTOMATIC = 0,
DISALLOWED = 2, DISALLOWED = 2,
PREFERRED = 1, PREFERRED = 1,
} }
const enum NSStatusItemLength : inline CGFloat constdef NSStatusItemLength : inline CGFloat
{ {
VARIABLE = -1.0, VARIABLE = -1.0,
SQUARE = -2.0 SQUARE = -2.0
} }
const enum NSApplicationTerminateReply : inline NSUInteger constdef NSApplicationTerminateReply : inline NSUInteger
{ {
CANCEL = 0, CANCEL = 0,
NOW = 1, NOW = 1,

2
lib/std/os/win32/console.c3
View File

@@ -1,6 +1,6 @@
module std::os::win32 @if(env::WIN32); module std::os::win32 @if(env::WIN32);
const enum Win32_CODEPAGE : Win32_UINT constdef Win32_CODEPAGE : Win32_UINT
{ {
IBM037 = 037, // IBM EBCDIC US-Canada IBM037 = 037, // IBM EBCDIC US-Canada
IBM437 = 437, // OEM United States IBM437 = 437, // OEM United States

6
lib/std/os/win32/memoryapi.c3
View File

@@ -1,6 +1,6 @@
module std::os::win32 @if(env::WIN32); module std::os::win32 @if(env::WIN32);
const enum Win32_AllocationType constdef Win32_AllocationType
{ {
MEM_COMMIT = 0x00001000, MEM_COMMIT = 0x00001000,
MEM_RESERVE = 0x00002000, MEM_RESERVE = 0x00002000,
@@ -12,7 +12,7 @@ const enum Win32_AllocationType
MEM_WRITE_WATCH = 0x00200000 MEM_WRITE_WATCH = 0x00200000
} }
const enum Win32_Protect : Win32_DWORD constdef Win32_Protect : Win32_DWORD
{ {
PAGE_EXECUTE = 0x10, PAGE_EXECUTE = 0x10,
PAGE_EXECUTE_READ = 0x20, PAGE_EXECUTE_READ = 0x20,
@@ -29,7 +29,7 @@ const enum Win32_Protect : Win32_DWORD
PAGE_WRITECOMBINE = 0x400, PAGE_WRITECOMBINE = 0x400,
} }
const enum Win32_FreeType : Win32_DWORD constdef Win32_FreeType : Win32_DWORD
{ {
MEM_DECOMMIT = 0x00004000, MEM_DECOMMIT = 0x00004000,
MEM_RELEASE = 0x00008000, MEM_RELEASE = 0x00008000,

2
lib/std/os/win32/winnt.c3
View File

@@ -13,7 +13,7 @@ enum Win32_MEM_EXTENDED_PARAMETER_TYPE : CInt
} }
alias Win32_PMEM_EXTENDED_PARAMETER_TYPE = Win32_MEM_EXTENDED_PARAMETER_TYPE; alias Win32_PMEM_EXTENDED_PARAMETER_TYPE = Win32_MEM_EXTENDED_PARAMETER_TYPE;
const enum Win32_MEM_EXTENDED_PARAMETER_ATTRIBUTE : Win32_DWORD64 constdef Win32_MEM_EXTENDED_PARAMETER_ATTRIBUTE : Win32_DWORD64
{ {
<* The allocation is non-pageable. *> <* The allocation is non-pageable. *>
NONPAGED = 0x02, NONPAGED = 0x02,

6
releasenotes.md
View File

@@ -9,7 +9,6 @@
- Integrated download of the MSVC SDK when compiling for Windows. - Integrated download of the MSVC SDK when compiling for Windows.
- For `c3c init` with library templates, provide example exported functions. #2898 - For `c3c init` with library templates, provide example exported functions. #2898
- `unsigned % signed` and `unsigned / signed` is no longer allowed without explicit casts, except for const denominators. #2928 - `unsigned % signed` and `unsigned / signed` is no longer allowed without explicit casts, except for const denominators. #2928
- New const enum declaration syntax.
- New enum associated value syntax. - New enum associated value syntax.
- Individual warning settings added. - Individual warning settings added.
- Change typedef and const enums to not convert from literals by default. - Change typedef and const enums to not convert from literals by default.
@@ -17,7 +16,10 @@
- Include actual element count in the error message when the array initializer size does not match the expected size. - Include actual element count in the error message when the array initializer size does not match the expected size.
- Add `--print-large-functions` for checking which functions likely dominate the compile time. - Add `--print-large-functions` for checking which functions likely dominate the compile time.
- Improve error message when providing `alias` with a typeid expression where a type was expected. #2944 - Improve error message when providing `alias` with a typeid expression where a type was expected. #2944
- Const enums removed.
- Constdef declarations introduced.
### Stdlib changes ### Stdlib changes
- Summarize sort macros as generic function wrappers to reduce the amount of generated code. #2831 - Summarize sort macros as generic function wrappers to reduce the amount of generated code. #2831
- Remove dependency on temp allocator in String.join. - Remove dependency on temp allocator in String.join.

10
resources/examples/opengl/src/gl/gl.c3
View File

@@ -1,15 +1,13 @@
module gl; module gl;
alias BitField = int; constdef BufferBit : int
enum BufferBit : int (int value)
{ {
COLOR = 0x00004000, COLOR = 0x00004000,
STENCIL = 0x00000400, STENCIL = 0x00000400,
DEPTH = 0x00000100, DEPTH = 0x00000100,
} }
enum Primitive : int (int value) constdef Primitive : int
{ {
POINTS = 0, POINTS = 0,
LINES = 1, LINES = 1,
@@ -23,9 +21,9 @@ enum Primitive : int (int value)
POLYGON = 9, POLYGON = 9,
} }
extern fn void clear(BitField mask) @cname("glClear") @public; extern fn void clear(BufferBit mask) @cname("glClear") @public;
extern fn void begin(BitField mask) @cname("glBegin") @public; extern fn void begin(BufferBit mask) @cname("glBegin") @public;
extern fn void end() @cname("glEnd") @public; extern fn void end() @cname("glEnd") @public;

10
resources/examples/raylib/raylib_2d_camera_platformer.c3
View File

@@ -45,11 +45,11 @@ alias CameraUpdateFn = fn void(RLCamera2D* camera, Player* player, EnvItem[] env
enum CameraUpdateType : (ZString text, CameraUpdateFn func) enum CameraUpdateType : (ZString text, CameraUpdateFn func)
{ {
CENTER = { "Follow player center", &update_camera_center }, CENTER { "Follow player center", &update_camera_center },
CENTER_INSIDE_MAP = { "Follow player center, but clamp to map edges", &update_camera_center_inside_map }, CENTER_INSIDE_MAP { "Follow player center, but clamp to map edges", &update_camera_center_inside_map },
CENTER_SMOOTH_FOLLOW = { "Follow player center; smoothed", &update_camera_center_smooth_follow }, CENTER_SMOOTH_FOLLOW { "Follow player center; smoothed", &update_camera_center_smooth_follow },
EVEN_OUT_ON_LANDING = { "Follow player center horizontally; update player center vertically after landing", &update_camera_even_out_on_landing }, EVEN_OUT_ON_LANDING { "Follow player center horizontally; update player center vertically after landing", &update_camera_even_out_on_landing },
PLAYER_BOUNDS_PUSH = { "Player push camera on getting too close to screen edge", &update_camera_player_bounds_push } PLAYER_BOUNDS_PUSH { "Player push camera on getting too close to screen edge", &update_camera_player_bounds_push }
} }
//------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------

8
resources/examples/raylib/raylib_snake.c3
View File

@@ -18,10 +18,10 @@ const int SCREEN_HEIGHT = 450;
enum SnakeDirection : (RLVector2 dir) enum SnakeDirection : (RLVector2 dir)
{ {
RIGHT = { SQUARE_SIZE, 0 }, RIGHT {{ SQUARE_SIZE, 0 }},
DOWN = { 0, SQUARE_SIZE }, DOWN {{ 0, SQUARE_SIZE }},
LEFT = { -SQUARE_SIZE, 0 }, LEFT {{ -SQUARE_SIZE, 0 }},
UP = { 0, -SQUARE_SIZE } UP {{ 0, -SQUARE_SIZE }}
} }
struct Snake struct Snake
{ {

57
scripts/tools/ci_tests.sh
View File

@@ -64,35 +64,36 @@ cd "$ROOT_DIR/resources"
run_examples() { run_examples() {
echo "--- Running Standard Examples ---" echo "--- Running Standard Examples ---"
"$C3C_BIN" compile examples/base64.c3 "$C3C_BIN" compile-only -vv examples/base64.c3 --target linux-x64
"$C3C_BIN" compile examples/binarydigits.c3 "$C3C_BIN" compile -vv examples/base64.c3
"$C3C_BIN" compile examples/brainfk.c3 "$C3C_BIN" compile -vv examples/binarydigits.c3
"$C3C_BIN" compile examples/factorial_macro.c3 "$C3C_BIN" compile -vv examples/brainfk.c3
"$C3C_BIN" compile examples/fasta.c3 "$C3C_BIN" compile -vv examples/factorial_macro.c3
"$C3C_BIN" compile examples/gameoflife.c3 "$C3C_BIN" compile -vv examples/fasta.c3
"$C3C_BIN" compile examples/hash.c3 "$C3C_BIN" compile -vv examples/gameoflife.c3
"$C3C_BIN" compile-only examples/levenshtein.c3 "$C3C_BIN" compile -vv examples/hash.c3
"$C3C_BIN" compile examples/load_world.c3 "$C3C_BIN" compile-only -vv examples/levenshtein.c3
"$C3C_BIN" compile-only examples/map.c3 "$C3C_BIN" compile -vv examples/load_world.c3
"$C3C_BIN" compile examples/mandelbrot.c3 "$C3C_BIN" compile-only -vv examples/map.c3
"$C3C_BIN" compile examples/plus_minus.c3 "$C3C_BIN" compile -vv examples/mandelbrot.c3
"$C3C_BIN" compile examples/nbodies.c3 "$C3C_BIN" compile -vv examples/plus_minus.c3
"$C3C_BIN" compile examples/spectralnorm.c3 "$C3C_BIN" compile -vv examples/nbodies.c3
"$C3C_BIN" compile examples/swap.c3 "$C3C_BIN" compile -vv examples/spectralnorm.c3
"$C3C_BIN" compile examples/contextfree/boolerr.c3 "$C3C_BIN" compile -vv examples/swap.c3
"$C3C_BIN" compile examples/contextfree/dynscope.c3 "$C3C_BIN" compile -vv examples/contextfree/boolerr.c3
"$C3C_BIN" compile examples/contextfree/guess_number.c3 "$C3C_BIN" compile -vv examples/contextfree/dynscope.c3
"$C3C_BIN" compile examples/contextfree/multi.c3 "$C3C_BIN" compile -vv examples/contextfree/guess_number.c3
"$C3C_BIN" compile examples/contextfree/cleanup.c3 "$C3C_BIN" compile -vv examples/contextfree/multi.c3
"$C3C_BIN" compile -vv examples/contextfree/cleanup.c3
"$C3C_BIN" compile-run examples/hello_world_many.c3 "$C3C_BIN" compile-run -vv examples/hello_world_many.c3
"$C3C_BIN" compile-run examples/time.c3 "$C3C_BIN" compile-run -vv examples/time.c3
"$C3C_BIN" compile-run examples/fannkuch-redux.c3 "$C3C_BIN" compile-run -vv examples/fannkuch-redux.c3
"$C3C_BIN" compile-run examples/contextfree/boolerr.c3 "$C3C_BIN" compile-run -vv examples/contextfree/boolerr.c3
"$C3C_BIN" compile-run examples/load_world.c3 "$C3C_BIN" compile-run -vv examples/load_world.c3
"$C3C_BIN" compile-run examples/process.c3 "$C3C_BIN" compile-run -vv examples/process.c3
"$C3C_BIN" compile-run examples/ls.c3 "$C3C_BIN" compile-run -vv examples/ls.c3
"$C3C_BIN" compile-run examples/args.c3 -- foo -bar "baz baz" "$C3C_BIN" compile-run -vv examples/args.c3 -- foo -bar "baz baz"
if [[ "$OS_MODE" == "linux" ]]; then if [[ "$OS_MODE" == "linux" ]]; then
"$C3C_BIN" compile-run --linker=builtin linux_stack.c3 || echo "Warning: linux_stack builtin linker skipped" "$C3C_BIN" compile-run --linker=builtin linux_stack.c3 || echo "Warning: linux_stack builtin linker skipped"

6
src/compiler/ast.c
View File

@@ -68,7 +68,7 @@ Decl *decl_new_with_type(const char *name, SourceSpan span, DeclKind decl_type)
case DECL_ENUM: case DECL_ENUM:
kind = TYPE_ENUM; kind = TYPE_ENUM;
break; break;
case DECL_CONST_ENUM: case DECL_CONSTDEF:
kind = TYPE_CONST_ENUM; kind = TYPE_CONST_ENUM;
break; break;
case DECL_TYPEDEF: case DECL_TYPEDEF:
@@ -127,7 +127,7 @@ const char *decl_to_a_name(Decl *decl)
case DECL_ALIAS: case DECL_ALIAS_PATH: case DECL_TYPE_ALIAS: return "an alias"; case DECL_ALIAS: case DECL_ALIAS_PATH: case DECL_TYPE_ALIAS: return "an alias";
case DECL_TYPEDEF: return "a distinct type"; case DECL_TYPEDEF: return "a distinct type";
case DECL_ENUM: return "an enum"; case DECL_ENUM: return "an enum";
case DECL_CONST_ENUM: return "a raw enum"; case DECL_CONSTDEF: return "a set of constants";
case DECL_ENUM_CONSTANT: return "an enum value"; case DECL_ENUM_CONSTANT: return "an enum value";
case DECL_ERASED: return "an erased declaration"; case DECL_ERASED: return "an erased declaration";
case DECL_FAULT: return "a fault"; case DECL_FAULT: return "a fault";
@@ -346,7 +346,7 @@ bool decl_may_be_generic(Decl *decl)
case DECL_GENERIC_INSTANCE: case DECL_GENERIC_INSTANCE:
case DECL_IMPORT: case DECL_IMPORT:
case DECL_LABEL: case DECL_LABEL:
case DECL_CONST_ENUM: case DECL_CONSTDEF:
return false; return false;
case DECL_ATTRIBUTE: case DECL_ATTRIBUTE:
case DECL_BITSTRUCT: case DECL_BITSTRUCT:

14
src/compiler/compiler_internal.h
View File

@@ -565,7 +565,7 @@ typedef struct
AstId docs; AstId docs;
union union
{ {
struct struct // Function related
{ {
bool attr_inline : 1; bool attr_inline : 1;
bool attr_noinline : 1; bool attr_noinline : 1;
@@ -593,7 +593,7 @@ typedef struct
Decl **lambda_ct_parameters; Decl **lambda_ct_parameters;
}; };
}; };
struct struct // Macro related
{ {
DeclId body_param; DeclId body_param;
CompilationUnit *unit; CompilationUnit *unit;
@@ -4328,7 +4328,7 @@ INLINE void expr_rewrite_const_int(Expr *expr, Type *type, uint64_t v)
expr->type = type; expr->type = type;
expr->resolve_status = RESOLVE_DONE; expr->resolve_status = RESOLVE_DONE;
TypeKind kind = type_flatten(type)->type_kind; TypeKind kind = type_flatten(type)->type_kind;
(&expr->const_expr)->ixx.i.high = 0; expr->const_expr.ixx.i.high = 0;
if (type_kind_is_signed(kind)) if (type_kind_is_signed(kind))
{ {
if (v > (uint64_t)INT64_MAX) (&expr->const_expr)->ixx.i.high = UINT64_MAX; if (v > (uint64_t)INT64_MAX) (&expr->const_expr)->ixx.i.high = UINT64_MAX;
@@ -4350,10 +4350,10 @@ INLINE void expr_rewrite_const_int(Expr *expr, Type *type, uint64_t v)
break; break;
} }
} }
(&expr->const_expr)->ixx.i.low = v; expr->const_expr.ixx.i.low = v;
(&expr->const_expr)->ixx.type = kind; expr->const_expr.ixx.type = kind;
(&expr->const_expr)->is_character = false; expr->const_expr.is_character = false;
(&expr->const_expr)->const_kind = CONST_INTEGER; expr->const_expr.const_kind = CONST_INTEGER;
} }
INLINE void expr_rewrite_to_int_to_float(Expr *expr, Type *type) INLINE void expr_rewrite_to_int_to_float(Expr *expr, Type *type)

4
src/compiler/context.c
View File

@@ -164,7 +164,7 @@ void decl_register(CompilationUnit *unit, Decl *decl)
case DECL_BITSTRUCT: case DECL_BITSTRUCT:
case DECL_TYPEDEF: case DECL_TYPEDEF:
case DECL_ENUM: case DECL_ENUM:
case DECL_CONST_ENUM: case DECL_CONSTDEF:
case DECL_STRUCT: case DECL_STRUCT:
case DECL_TYPE_ALIAS: case DECL_TYPE_ALIAS:
case DECL_UNION: case DECL_UNION:
@@ -273,7 +273,7 @@ void unit_register_global_decl(CompilationUnit *unit, Decl *decl)
vec_add(unit->generic_defines, decl); vec_add(unit->generic_defines, decl);
decl_register(unit, decl); decl_register(unit, decl);
return; return;
case DECL_CONST_ENUM: case DECL_CONSTDEF:
case DECL_ENUM: case DECL_ENUM:
ASSERT(decl->name); ASSERT(decl->name);
vec_add(unit->enums, decl); vec_add(unit->enums, decl);

2
src/compiler/copying.c
View File

@@ -1117,7 +1117,7 @@ Decl *copy_decl(CopyStruct *c, Decl *decl)
break; break;
case DECL_FAULT: case DECL_FAULT:
break; break;
case DECL_CONST_ENUM: case DECL_CONSTDEF:
copy_decl_type(copy); copy_decl_type(copy);
MACRO_COPY_TYPE_LIST(copy->interfaces); MACRO_COPY_TYPE_LIST(copy->interfaces);
MACRO_COPY_DECL_METHODS(copy->method_table); MACRO_COPY_DECL_METHODS(copy->method_table);

4
src/compiler/enums.h
View File

@@ -1050,7 +1050,7 @@ typedef enum
DECL_LABEL, DECL_LABEL,
DECL_MACRO, DECL_MACRO,
DECL_INTERFACE, DECL_INTERFACE,
DECL_CONST_ENUM, DECL_CONSTDEF,
DECL_STRUCT, DECL_STRUCT,
DECL_TYPE_ALIAS, DECL_TYPE_ALIAS,
DECL_UNION, DECL_UNION,
@@ -1579,7 +1579,7 @@ typedef enum
TOKEN_BREAK, TOKEN_BREAK,
TOKEN_CASE, TOKEN_CASE,
TOKEN_CATCH, TOKEN_CATCH,
TOKEN_CENUM, TOKEN_CONSTDEF,
TOKEN_CONST, TOKEN_CONST,
TOKEN_CONTINUE, TOKEN_CONTINUE,
TOKEN_DEFAULT, TOKEN_DEFAULT,

2
src/compiler/json_output.c
View File

@@ -95,7 +95,7 @@ static inline const char *decl_type_to_string(Decl *type)
case DECL_STRUCT: return "struct"; case DECL_STRUCT: return "struct";
case DECL_UNION: return "union"; case DECL_UNION: return "union";
case DECL_TYPE_ALIAS: return "type_alias"; case DECL_TYPE_ALIAS: return "type_alias";
case DECL_CONST_ENUM: return "raw_enum"; case DECL_CONSTDEF: return "constdef";
case DECL_BODYPARAM: case DECL_BODYPARAM:
case DECL_DECLARRAY: case DECL_DECLARRAY:
case DECL_ERASED: case DECL_ERASED:

4
src/compiler/llvm_codegen.c
View File

@@ -1036,7 +1036,7 @@ static void llvm_emit_type_decls(GenContext *context, Decl *decl)
case DECL_UNION: case DECL_UNION:
case DECL_ENUM: case DECL_ENUM:
case DECL_BITSTRUCT: case DECL_BITSTRUCT:
case DECL_CONST_ENUM: case DECL_CONSTDEF:
llvm_get_typeid(context, decl->type); llvm_get_typeid(context, decl->type);
break; break;
} }
@@ -1389,7 +1389,7 @@ LLVMValueRef llvm_get_ref(GenContext *c, Decl *decl)
case DECL_CT_ASSERT: case DECL_CT_ASSERT:
case DECL_TYPEDEF: case DECL_TYPEDEF:
case DECL_ENUM: case DECL_ENUM:
case DECL_CONST_ENUM: case DECL_CONSTDEF:
case DECL_ENUM_CONSTANT: case DECL_ENUM_CONSTANT:
case DECL_IMPORT: case DECL_IMPORT:
case DECL_ALIAS_PATH: case DECL_ALIAS_PATH:

2
src/compiler/llvm_codegen_type.c
View File

@@ -25,7 +25,7 @@ static inline LLVMTypeRef llvm_type_from_decl(GenContext *c, Decl *decl)
UNREACHABLE_VOID UNREACHABLE_VOID
case DECL_TYPE_ALIAS: case DECL_TYPE_ALIAS:
return llvm_get_type(c, decl->type); return llvm_get_type(c, decl->type);
case DECL_CONST_ENUM: case DECL_CONSTDEF:
return llvm_get_type(c, decl->enums.type_info->type); return llvm_get_type(c, decl->enums.type_info->type);
case DECL_TYPEDEF: case DECL_TYPEDEF:
return llvm_get_type(c, decl->distinct->type); return llvm_get_type(c, decl->distinct->type);

56
src/compiler/parse_global.c
View File

@@ -13,7 +13,7 @@ typedef enum FunctionParse_
FUNC_PARSE_INTERFACE, FUNC_PARSE_INTERFACE,
} FunctionParse; } FunctionParse;
static inline Decl *parse_enum_declaration(ParseContext *c, bool is_const); static inline Decl *parse_enum_declaration(ParseContext *c);
static inline Decl *parse_func_definition(ParseContext *c, AstId contracts, FunctionParse parse_kind); static inline Decl *parse_func_definition(ParseContext *c, AstId contracts, FunctionParse parse_kind);
static inline bool parse_bitstruct_body(ParseContext *c, Decl *decl); static inline bool parse_bitstruct_body(ParseContext *c, Decl *decl);
static inline bool parse_enum_param_list(ParseContext *c, Decl*** parameters_ref, ArrayIndex *inline_index); static inline bool parse_enum_param_list(ParseContext *c, Decl*** parameters_ref, ArrayIndex *inline_index);
@@ -23,7 +23,6 @@ static bool parse_attributes_for_global(ParseContext *c, Decl *decl);
INLINE bool parse_decl_initializer(ParseContext *c, Decl *decl); INLINE bool parse_decl_initializer(ParseContext *c, Decl *decl);
INLINE Decl *decl_new_var_current(ParseContext *c, TypeInfo *type, VarDeclKind kind); INLINE Decl *decl_new_var_current(ParseContext *c, TypeInfo *type, VarDeclKind kind);
static bool parse_contracts(ParseContext *c, AstId *contracts_ref); static bool parse_contracts(ParseContext *c, AstId *contracts_ref);
static Ast *contracts_first_real(AstId contracts);
INLINE Decl *decl_new_var_current(ParseContext *c, TypeInfo *type, VarDeclKind kind) INLINE Decl *decl_new_var_current(ParseContext *c, TypeInfo *type, VarDeclKind kind)
{ {
@@ -2289,10 +2288,6 @@ static inline Decl *parse_bitstruct_declaration(ParseContext *c)
static inline Decl *parse_top_level_const_declaration(ParseContext *c, bool is_extern) static inline Decl *parse_top_level_const_declaration(ParseContext *c, bool is_extern)
{ {
if (!is_extern && peek(c) == TOKEN_ENUM)
{
return parse_enum_declaration(c, true);
}
ASSIGN_DECL_OR_RET(Decl *decl, parse_const_declaration(c, true, is_extern), poisoned_decl); ASSIGN_DECL_OR_RET(Decl *decl, parse_const_declaration(c, true, is_extern), poisoned_decl);
CONSUME_EOS_OR_RET(poisoned_decl); CONSUME_EOS_OR_RET(poisoned_decl);
return decl; return decl;
@@ -2795,7 +2790,7 @@ static inline bool parse_enum_param_list(ParseContext *c, Decl*** parameters_ref
return true; return true;
} }
static bool parse_enum_values(ParseContext *c, Decl*** values_ref, Visibility visibility, bool is_single_value, bool is_const_enum) static bool parse_enum_values(ParseContext *c, Decl*** values_ref, Visibility visibility, bool is_single_value, bool is_constdef)
{ {
Decl **values = NULL; Decl **values = NULL;
bool deprecate_warn = true; bool deprecate_warn = true;
@@ -2803,7 +2798,7 @@ static bool parse_enum_values(ParseContext *c, Decl*** values_ref, Visibility vi
{ {
if (!parse_element_contract(c, "enum values")) return false; if (!parse_element_contract(c, "enum values")) return false;
Decl *enum_const = decl_new(DECL_ENUM_CONSTANT, symstr(c), c->span); Decl *enum_const = decl_new(DECL_ENUM_CONSTANT, symstr(c), c->span);
if (is_const_enum) enum_const->enum_constant.is_raw = is_const_enum; if (is_constdef) enum_const->enum_constant.is_raw = is_constdef;
enum_const->visibility = visibility; enum_const->visibility = visibility;
const char *name = enum_const->name; const char *name = enum_const->name;
if (!consume_const_name(c, "enum constant")) return false; if (!consume_const_name(c, "enum constant")) return false;
@@ -2820,7 +2815,7 @@ static bool parse_enum_values(ParseContext *c, Decl*** values_ref, Visibility vi
if (try_consume(c, TOKEN_EQ)) if (try_consume(c, TOKEN_EQ))
{ {
Expr **args = NULL; Expr **args = NULL;
if (!is_const_enum && deprecate_warn) if (!is_constdef && deprecate_warn)
{ {
deprecate_warn = false; deprecate_warn = false;
print_deprecation_at(c->prev_span, "Use () declaration of associated values instead."); print_deprecation_at(c->prev_span, "Use () declaration of associated values instead.");
@@ -2828,7 +2823,7 @@ static bool parse_enum_values(ParseContext *c, Decl*** values_ref, Visibility vi
if (is_single_value || !tok_is(c, TOKEN_LBRACE)) if (is_single_value || !tok_is(c, TOKEN_LBRACE))
{ {
ASSIGN_EXPR_OR_RET(Expr *single, parse_constant_expr(c), false); ASSIGN_EXPR_OR_RET(Expr *single, parse_constant_expr(c), false);
if (is_const_enum) if (is_constdef)
{ {
enum_const->enum_constant.value = single; enum_const->enum_constant.value = single;
goto NEXT; goto NEXT;
@@ -2862,7 +2857,7 @@ static bool parse_enum_values(ParseContext *c, Decl*** values_ref, Visibility vi
} }
enum_const->enum_constant.associated = args; enum_const->enum_constant.associated = args;
} }
else if (!is_const_enum && try_consume(c, TOKEN_LBRACE)) else if (!is_constdef && try_consume(c, TOKEN_LBRACE))
{ {
Expr **args = NULL; Expr **args = NULL;
while (1) while (1)
@@ -2913,13 +2908,13 @@ NEXT:
* enum_body ::= enum_def (',' enum_def)* ','? * enum_body ::= enum_def (',' enum_def)* ','?
* enum_def ::= CONST_IDENT ('(' arg_list ')')? * enum_def ::= CONST_IDENT ('(' arg_list ')')?
*/ */
static inline Decl *parse_enum_declaration(ParseContext *c, bool is_const) static inline Decl *parse_enum_declaration(ParseContext *c)
{ {
if (is_const) advance_and_verify(c, TOKEN_CONST); bool is_constdef = false;
if (tok_is(c, TOKEN_CENUM)) if (tok_is(c, TOKEN_CONSTDEF))
{ {
advance_and_verify(c, TOKEN_CENUM); advance_and_verify(c, TOKEN_CONSTDEF);
is_const = true; is_constdef = true;
} }
else else
{ {
@@ -2928,23 +2923,22 @@ static inline Decl *parse_enum_declaration(ParseContext *c, bool is_const)
const char *name = symstr(c); const char *name = symstr(c);
SourceSpan span = c->span; SourceSpan span = c->span;
if (!consume_type_name(c, "enum")) return poisoned_decl; if (!consume_type_name(c, is_constdef ? "constdef" : "enum" )) return poisoned_decl;
TypeInfo **interfaces = NULL; TypeInfo **interfaces = NULL;
if (!parse_interface_impls(c, &interfaces)) return poisoned_decl; if (!parse_interface_impls(c, &interfaces)) return poisoned_decl;
TypeInfo *type = NULL; TypeInfo *type = NULL;
bool val_is_inline = false; bool val_is_inline = false;
ArrayIndex inline_index = -1; ArrayIndex inline_index = -1;
bool is_const_enum = is_const;
Decl **param_list = NULL; Decl **param_list = NULL;
if (try_consume(c, TOKEN_COLON)) if (try_consume(c, TOKEN_COLON))
{ {
if (!is_const) if (!is_constdef)
{ {
is_const_enum = try_consume(c, TOKEN_CONST); is_constdef = try_consume(c, TOKEN_CONST);
if (is_const_enum) if (is_constdef)
{ {
print_deprecation_at(c->prev_span, "Declare const enums using 'const enum' instead."); print_deprecation_at(c->prev_span, "Declare constdefs using 'constdef' instead.");
} }
} }
if (!tok_is(c, TOKEN_LPAREN) && !tok_is(c, TOKEN_LBRACE)) if (!tok_is(c, TOKEN_LPAREN) && !tok_is(c, TOKEN_LBRACE))
@@ -2953,14 +2947,14 @@ static inline Decl *parse_enum_declaration(ParseContext *c, bool is_const)
ASSIGN_TYPE_OR_RET(type, parse_optional_type_no_generic(c), poisoned_decl); ASSIGN_TYPE_OR_RET(type, parse_optional_type_no_generic(c), poisoned_decl);
if (type->optional) if (type->optional)
{ {
RETURN_PRINT_ERROR_AT(poisoned_decl, type, "An enum can't have an optional type."); RETURN_PRINT_ERROR_AT(poisoned_decl, type, "An enum or constdef can't have an optional type.");
} }
} }
if (is_const_enum) if (is_constdef)
{ {
if (tok_is(c, TOKEN_LPAREN)) if (tok_is(c, TOKEN_LPAREN))
{ {
PRINT_ERROR_HERE("Const enums cannot have associated values."); PRINT_ERROR_HERE("Constdefs cannot have associated values.");
return poisoned_decl; return poisoned_decl;
} }
} }
@@ -2970,7 +2964,7 @@ static inline Decl *parse_enum_declaration(ParseContext *c, bool is_const)
} }
} }
Decl *decl = decl_new_with_type(name, span, is_const_enum ? DECL_CONST_ENUM : DECL_ENUM); Decl *decl = decl_new_with_type(name, span, is_constdef ? DECL_CONSTDEF : DECL_ENUM);
decl->interfaces = interfaces; decl->interfaces = interfaces;
if (param_list) decl->enums.parameters = param_list; if (param_list) decl->enums.parameters = param_list;
if (!parse_attributes_for_global(c, decl)) return poisoned_decl; if (!parse_attributes_for_global(c, decl)) return poisoned_decl;
@@ -2980,9 +2974,9 @@ static inline Decl *parse_enum_declaration(ParseContext *c, bool is_const)
decl->enums.type_info = type ? type : type_info_new_base(type_int, decl->span); decl->enums.type_info = type ? type : type_info_new_base(type_int, decl->span);
decl->enums.inline_index = (int16_t)inline_index; decl->enums.inline_index = (int16_t)inline_index;
decl->enums.inline_value = is_const_enum ? false : val_is_inline; decl->enums.inline_value = is_constdef ? false : val_is_inline;
if (is_const_enum && val_is_inline) decl->is_substruct = true; if (is_constdef && val_is_inline) decl->is_substruct = true;
if (!parse_enum_values(c, &decl->enums.values, visibility, is_const_enum || expected_parameters == 1, is_const_enum)) return poisoned_decl; if (!parse_enum_values(c, &decl->enums.values, visibility, is_constdef || expected_parameters == 1, is_constdef)) return poisoned_decl;
return decl; return decl;
} }
@@ -3642,8 +3636,8 @@ Decl *parse_top_level_statement(ParseContext *c, ParseContext **context_out)
decl = parse_macro_declaration(c, contracts); decl = parse_macro_declaration(c, contracts);
break; break;
case TOKEN_ENUM: case TOKEN_ENUM:
case TOKEN_CENUM: case TOKEN_CONSTDEF:
decl = parse_enum_declaration(c, false); decl = parse_enum_declaration(c);
attach_contracts = true; attach_contracts = true;
break; break;
case TOKEN_FAULTDEF: case TOKEN_FAULTDEF:

2
src/compiler/parse_stmt.c
View File

@@ -1444,7 +1444,7 @@ Ast *parse_stmt(ParseContext *c)
case TOKEN_BIT_AND_ASSIGN: case TOKEN_BIT_AND_ASSIGN:
case TOKEN_BIT_OR_ASSIGN: case TOKEN_BIT_OR_ASSIGN:
case TOKEN_BIT_XOR_ASSIGN: case TOKEN_BIT_XOR_ASSIGN:
case TOKEN_CENUM: case TOKEN_CONSTDEF:
case TOKEN_COLON: case TOKEN_COLON:
case TOKEN_COMMA: case TOKEN_COMMA:
case TOKEN_CT_CASE: case TOKEN_CT_CASE:

4
src/compiler/sema_casts.c
View File

@@ -1238,7 +1238,7 @@ RETRY:;
inner = decl->strukt.members[0]->type->canonical; inner = decl->strukt.members[0]->type->canonical;
break; break;
case DECL_ENUM: case DECL_ENUM:
case DECL_CONST_ENUM: case DECL_CONSTDEF:
// Could be made to work. // Could be made to work.
return false; return false;
default: default:
@@ -1656,7 +1656,7 @@ static bool rule_enum_to_value(CastContext *cc, bool is_explicit, bool is_silent
return cast_is_allowed(cc, is_explicit, is_silent); return cast_is_allowed(cc, is_explicit, is_silent);
} }
ASSERT(enum_decl->decl_kind != DECL_CONST_ENUM); ASSERT(enum_decl->decl_kind != DECL_CONSTDEF);
Type *inner = enum_decl->enums.type_info->type; Type *inner = enum_decl->enums.type_info->type;
if (!type_is_integer_or_bool_kind(type_flatten(cc->to))) if (!type_is_integer_or_bool_kind(type_flatten(cc->to)))

26
src/compiler/sema_decls.c
View File

@@ -71,7 +71,7 @@ static inline bool sema_resolve_align_expr(SemaContext *context, Expr *expr, Ali
} }
static inline bool sema_analyse_enum_param(SemaContext *context, Decl *param); static inline bool sema_analyse_enum_param(SemaContext *context, Decl *param);
static inline bool sema_analyse_enum(SemaContext *context, Decl *decl, bool *erase_decl); static inline bool sema_analyse_enum(SemaContext *context, Decl *decl, bool *erase_decl);
static inline bool sema_analyse_raw_enum(SemaContext *context, Decl *decl, bool *erase_decl); static inline bool sema_analyse_constdef(SemaContext *context, Decl *decl, bool *erase_decl);
static bool sema_check_section(SemaContext *context, Attr *attr) static bool sema_check_section(SemaContext *context, Attr *attr)
{ {
@@ -1636,11 +1636,11 @@ static inline void sema_print_enum_to_cenum_error(SemaContext *context, Decl *de
TypeInfo *type_info = decl->enums.type_info; TypeInfo *type_info = decl->enums.type_info;
if (type_info->type == type_int) if (type_info->type == type_int)
{ {
SEMA_ERROR(arg, "Assigning a value requires the declaration of associated values for the enum. Did you perhaps want C-style enums? In that case use const enums, defined like 'enum %s : const { ... }'", decl->name); SEMA_ERROR(arg, "Assigning a value requires the declaration of associated values for the enum. Did you perhaps want C-style enums? In that case use constdef, defined like 'constdef %s : { ... }'", decl->name);
} }
else else
{ {
SEMA_ERROR(arg, "Assigning a value requires the declaration of associated values for the enum. Did you perhaps want C-style enums? In that case use const enums, defined like 'enum %s : const %s { ... }'", decl->name, type_to_error_string(type_info->type)); SEMA_ERROR(arg, "Assigning a value requires the declaration of associated values for the enum. Did you perhaps want C-style enums? In that case use constdef, defined like 'constdef %s : %s { ... }'", decl->name, type_to_error_string(type_info->type));
} }
} }
static inline bool sema_analyse_enum(SemaContext *context, Decl *decl, bool *erase_decl) static inline bool sema_analyse_enum(SemaContext *context, Decl *decl, bool *erase_decl)
@@ -1812,7 +1812,7 @@ static bool sema_analyse_const_enum_constant_val(SemaContext *context, Decl *dec
} }
return true; return true;
} }
static inline bool sema_analyse_raw_enum(SemaContext *context, Decl *decl, bool *erase_decl) static inline bool sema_analyse_constdef(SemaContext *context, Decl *decl, bool *erase_decl)
{ {
if (!sema_analyse_attributes(context, decl, decl->attributes, ATTR_ENUM, erase_decl)) return decl_poison(decl); if (!sema_analyse_attributes(context, decl, decl->attributes, ATTR_ENUM, erase_decl)) return decl_poison(decl);
if (*erase_decl) return true; if (*erase_decl) return true;
@@ -1836,18 +1836,18 @@ static inline bool sema_analyse_raw_enum(SemaContext *context, Decl *decl, bool
SEMA_ERROR(decl->enums.type_info, "No type can be inferred from the optional result."); SEMA_ERROR(decl->enums.type_info, "No type can be inferred from the optional result.");
return decl_poison(decl); return decl_poison(decl);
case STORAGE_VOID: case STORAGE_VOID:
SEMA_ERROR(decl->enums.type_info, "An enum may not have a void type."); SEMA_ERROR(decl->enums.type_info, "A constdef may not have a void type.");
return decl_poison(decl); return decl_poison(decl);
case STORAGE_COMPILE_TIME: case STORAGE_COMPILE_TIME:
SEMA_ERROR(decl->enums.type_info, "An enum may not be %s.", type_invalid_storage_type_name(type)); SEMA_ERROR(decl->enums.type_info, "A constdef may not be %s.", type_invalid_storage_type_name(type));
return decl_poison(decl); return decl_poison(decl);
case STORAGE_UNKNOWN: case STORAGE_UNKNOWN:
SEMA_ERROR(decl->enums.type_info, "An enum may not be %s, as it has an unknown size.", SEMA_ERROR(decl->enums.type_info, "A constdef may not be %s, as it has an unknown size.",
type_quoted_error_string(type)); type_quoted_error_string(type));
return decl_poison(decl); return decl_poison(decl);
} }
DEBUG_LOG("* Raw enum type resolved to %s.", type->name); DEBUG_LOG("* Constdef type resolved to %s.", type->name);
ASSERT_SPAN(decl, !decl->enums.parameters); ASSERT_SPAN(decl, !decl->enums.parameters);
@@ -1865,7 +1865,7 @@ static inline bool sema_analyse_raw_enum(SemaContext *context, Decl *decl, bool
{ {
if (enums == 1) if (enums == 1)
{ {
RETURN_SEMA_ERROR(decl, "No enum values left in enum after @if resolution, there must be at least one."); RETURN_SEMA_ERROR(decl, "No constdef values left in constdef after @if resolution, there must be at least one.");
} }
vec_erase_at(enum_values, i); vec_erase_at(enum_values, i);
enums--; enums--;
@@ -1873,12 +1873,12 @@ static inline bool sema_analyse_raw_enum(SemaContext *context, Decl *decl, bool
continue; continue;
} }
enum_value->type = decl->type; enum_value->type = decl->type;
DEBUG_LOG("* Checking enum constant %s.", enum_value->name); DEBUG_LOG("* Checking constdef constant %s.", enum_value->name);
if (!enum_value->enum_constant.value) if (!enum_value->enum_constant.value)
{ {
if (!type_is_integer(flat)) if (!type_is_integer(flat))
{ {
RETURN_SEMA_ERROR(enum_value, "Enums with missing values must be an integer type."); RETURN_SEMA_ERROR(enum_value, "Constdefs with missing values must be of integer type.");
} }
if (i == 0) if (i == 0)
{ {
@@ -5733,8 +5733,8 @@ bool sema_analyse_decl(SemaContext *context, Decl *decl)
case DECL_ENUM: case DECL_ENUM:
if (!sema_analyse_enum(context, decl, &erase_decl)) goto FAILED; if (!sema_analyse_enum(context, decl, &erase_decl)) goto FAILED;
break; break;
case DECL_CONST_ENUM: case DECL_CONSTDEF:
if (!sema_analyse_raw_enum(context, decl, &erase_decl)) goto FAILED; if (!sema_analyse_constdef(context, decl, &erase_decl)) goto FAILED;
break; break;
case DECL_FAULT: case DECL_FAULT:
if (!sema_analyse_fault(context, decl, &erase_decl)) goto FAILED; if (!sema_analyse_fault(context, decl, &erase_decl)) goto FAILED;

26
src/compiler/sema_expr.c
View File

@@ -999,8 +999,10 @@ static inline bool sema_cast_ident_rvalue(SemaContext *context, Expr *expr)
case DECL_UNION: case DECL_UNION:
SEMA_ERROR(expr, "Expected union followed by {...} or '.'."); SEMA_ERROR(expr, "Expected union followed by {...} or '.'.");
return expr_poison(expr); return expr_poison(expr);
case DECL_CONSTDEF:
SEMA_ERROR(expr, "Expected constdef name followed by '.' and a constdef value.");
return expr_poison(expr);
case DECL_ENUM: case DECL_ENUM:
case DECL_CONST_ENUM:
SEMA_ERROR(expr, "Expected enum name followed by '.' and an enum value."); SEMA_ERROR(expr, "Expected enum name followed by '.' and an enum value.");
return expr_poison(expr); return expr_poison(expr);
} }
@@ -1187,7 +1189,14 @@ static inline bool sema_expr_analyse_enum_constant(SemaContext *context, Expr *e
if (enum_constant->resolve_status == RESOLVE_NOT_DONE) if (enum_constant->resolve_status == RESOLVE_NOT_DONE)
{ {
SEMA_ERROR(expr, "Unable to properly resolve enum constant value, this can sometimes happen in recursive definitions."); if (decl->decl_kind == DECL_ENUM)
{
SEMA_ERROR(expr, "Unable to properly resolve enum constant value, this can sometimes happen in recursive definitions.");
}
else
{
SEMA_ERROR(expr, "Unable to properly resolve constdef value, this can sometimes happen in recursive definitions.");
}
return expr_poison(expr), true; return expr_poison(expr), true;
} }
expr->type = decl->type; expr->type = decl->type;
@@ -3502,7 +3511,7 @@ INLINE bool sema_expr_analyse_from_ordinal(SemaContext *context, Expr *expr, Exp
{ {
RETURN_SEMA_ERROR(key, "The ordinal should be an integer."); RETURN_SEMA_ERROR(key, "The ordinal should be an integer.");
} }
bool is_const_enum = decl->decl_kind == DECL_CONST_ENUM; bool is_const_enum = decl->decl_kind == DECL_CONSTDEF;
if (sema_cast_const(key)) if (sema_cast_const(key))
{ {
Int to_convert = key->const_expr.ixx; Int to_convert = key->const_expr.ixx;
@@ -3532,7 +3541,7 @@ INLINE bool sema_expr_analyse_from_ordinal(SemaContext *context, Expr *expr, Exp
} }
if (is_const_enum) if (is_const_enum)
{ {
RETURN_SEMA_ERROR(key, ".from_ordinal on const enums is only valid with compile time constant arguments, maybe you can try using regular enums?"); RETURN_SEMA_ERROR(key, ".from_ordinal on constdefs is only valid with compile time constant arguments, maybe you want to use enums instead?");
} }
expr->expr_kind = EXPR_ENUM_FROM_ORD; expr->expr_kind = EXPR_ENUM_FROM_ORD;
expr->inner_expr = key; expr->inner_expr = key;
@@ -5086,15 +5095,18 @@ static inline bool sema_expr_analyse_type_access(SemaContext *context, Expr *exp
switch (decl->decl_kind) switch (decl->decl_kind)
{ {
case DECL_ENUM: case DECL_ENUM:
case DECL_CONST_ENUM: case DECL_CONSTDEF:
if (is_const) if (is_const)
{ {
if (!sema_expr_analyse_enum_constant(context, expr, name, decl)) if (!sema_expr_analyse_enum_constant(context, expr, name, decl))
{ {
if (missing_ref) goto MISSING_REF; if (missing_ref) goto MISSING_REF;
if (!decl_ok(decl)) return false; if (!decl_ok(decl)) return false;
if (decl->decl_kind != DECL_ENUM)
{
RETURN_SEMA_ERROR(expr, "'%s' has no value '%s'.", decl->name, name);
}
RETURN_SEMA_ERROR(expr, "'%s' has no enumeration value '%s'.", decl->name, name); RETURN_SEMA_ERROR(expr, "'%s' has no enumeration value '%s'.", decl->name, name);
return false;
} }
return expr_ok(expr); return expr_ok(expr);
} }
@@ -10522,7 +10534,7 @@ static inline bool sema_expr_analyse_ct_nameof(SemaContext *context, Expr *expr,
case DECL_BITSTRUCT: case DECL_BITSTRUCT:
case DECL_TYPEDEF: case DECL_TYPEDEF:
case DECL_ENUM: case DECL_ENUM:
case DECL_CONST_ENUM: case DECL_CONSTDEF:
case DECL_ENUM_CONSTANT: case DECL_ENUM_CONSTANT:
case DECL_FNTYPE: case DECL_FNTYPE:
case DECL_FUNC: case DECL_FUNC:

2
src/compiler/sema_liveness.c
View File

@@ -604,7 +604,7 @@ RETRY:
case DECL_TYPEDEF: case DECL_TYPEDEF:
sema_trace_type_liveness(decl->distinct->type); sema_trace_type_liveness(decl->distinct->type);
FALLTHROUGH; FALLTHROUGH;
case DECL_CONST_ENUM: case DECL_CONSTDEF:
case DECL_BITSTRUCT: case DECL_BITSTRUCT:
case DECL_INTERFACE: case DECL_INTERFACE:
case DECL_UNION: case DECL_UNION:

2
src/compiler/sema_types.c
View File

@@ -243,7 +243,7 @@ static bool sema_resolve_type_identifier(SemaContext *context, TypeInfo *type_in
type_info->type = decl->type; type_info->type = decl->type;
type_info->resolve_status = RESOLVE_DONE; type_info->resolve_status = RESOLVE_DONE;
return true; return true;
case DECL_CONST_ENUM: case DECL_CONSTDEF:
case DECL_TYPEDEF: case DECL_TYPEDEF:
if (resolve_type_kind & RESOLVE_TYPE_NO_CHECK_DISTINCT) if (resolve_type_kind & RESOLVE_TYPE_NO_CHECK_DISTINCT)
{ {

2
src/compiler/semantic_analyser.c
View File

@@ -262,7 +262,7 @@ static void register_generic_decls(CompilationUnit *unit, Decl **decls)
case DECL_ALIAS: case DECL_ALIAS:
case DECL_ATTRIBUTE: case DECL_ATTRIBUTE:
case DECL_BITSTRUCT: case DECL_BITSTRUCT:
case DECL_CONST_ENUM: case DECL_CONSTDEF:
case DECL_TYPEDEF: case DECL_TYPEDEF:
case DECL_ENUM: case DECL_ENUM:
case DECL_INTERFACE: case DECL_INTERFACE:

4
src/compiler/tokens.c
View File

@@ -199,12 +199,12 @@ const char *token_type_to_string(TokenType type)
return "break"; return "break";
case TOKEN_CASE: case TOKEN_CASE:
return "case"; return "case";
case TOKEN_CENUM:
return "cenum";
case TOKEN_CATCH: case TOKEN_CATCH:
return "catch"; return "catch";
case TOKEN_CONST: case TOKEN_CONST:
return "const"; return "const";
case TOKEN_CONSTDEF:
return "constdef";
case TOKEN_CONTINUE: case TOKEN_CONTINUE:
return "continue"; return "continue";
case TOKEN_DEFAULT: case TOKEN_DEFAULT:

4
src/compiler/types.c
View File

@@ -2131,7 +2131,7 @@ RETRY_DISTINCT:
return NULL; return NULL;
case ALL_INTS: case ALL_INTS:
{ {
// If Foo + 1, then we allow this if Foo is a distinct type or const enum that has // If Foo + 1, then we allow this if Foo is a distinct type or constdef that has
// integer or float as the base type. // integer or float as the base type.
if (first && type_is_distinct_like(other) && type_underlying_is_numeric(other) && expr_is_const(first)) return other; if (first && type_is_distinct_like(other) && type_underlying_is_numeric(other) && expr_is_const(first)) return other;
// See if we can flatten it. // See if we can flatten it.
@@ -2145,7 +2145,7 @@ RETRY_DISTINCT:
} }
case ALL_FLOATS: case ALL_FLOATS:
{ {
// If Foo + 1.0, then we allow this if Foo is a distinct type or const enum that has // If Foo + 1.0, then we allow this if Foo is a distinct type or constdef that has
// float as the base type. // float as the base type.
if (first && type_is_distinct_like(other) && type_underlying_is_numeric(other) && expr_is_const(first)) return other; if (first && type_is_distinct_like(other) && type_underlying_is_numeric(other) && expr_is_const(first)) return other;
// See if we can flatten it. // See if we can flatten it.

2
test/test_suite/any/generic_interface_stage.c3t
View File

@@ -1,7 +1,7 @@
import std; import std;
fn int foo() => 0; fn int foo() => 0;
alias FooFn = fn int(); alias FooFn = fn int();
const enum Bar : FooFn constdef Bar : FooFn
{ {
FOO = fn () => (int)(iptr)ExclusiveRange{int}.typeid, FOO = fn () => (int)(iptr)ExclusiveRange{int}.typeid,
BAR = &foo, BAR = &foo,

2
test/test_suite/enumerations/const_enum.c3
View File

@@ -1,6 +1,6 @@
import std::io; import std::io;
const enum MyEnum : inline CInt constdef MyEnum : inline CInt
{ {
FOO = 1, FOO = 1,
BAR = 5, BAR = 5,

2
test/test_suite/enumerations/const_enum_inline.c3t
View File

@@ -1,6 +1,6 @@
// #target: macos-x64 // #target: macos-x64
module test; module test;
const enum Foo : inline String constdef Foo : inline String
{ {
HELO = "Helo" HELO = "Helo"
} }

2
test/test_suite/enumerations/const_enum_inline_member.c3t
View File

@@ -5,7 +5,7 @@ struct Bar
uint x, y, z; uint x, y, z;
} }
const enum Foo : inline Bar constdef Foo : inline Bar
{ {
X = {1, 0, 0}, X = {1, 0, 0},
Y = {0, 1, 0}, Y = {0, 1, 0},

2
test/test_suite/enumerations/const_enum_methods.c3t
View File

@@ -1,7 +1,7 @@
// #target: macos-x64 // #target: macos-x64
module test; module test;
const enum Enum : int constdef Enum : int
{ {
E0, E1 E0, E1
} }

4
test/test_suite/enumerations/const_enum_self_ref.c3
View File

@@ -1,6 +1,6 @@
const enum MyEnum constdef MyEnum
{ {
VAL1 = VAL3, // #error: Unable to properly resolve enum constant value, this can sometimes happen in recursive definitions VAL1 = VAL3, // #error: Unable to properly resolve constdef value, this can sometimes happen in recursive definitions
VAL2 , VAL2 ,
VAL3 VAL3
} }

2
test/test_suite/enumerations/const_enum_vector.c3t
View File

@@ -2,7 +2,7 @@
module test; module test;
import std; import std;
const enum Color : char[<4>] constdef Color : char[<4>]
{ {
LIGHTGRAY = { 200, 200, 200, 255 }, LIGHTGRAY = { 200, 200, 200, 255 },
} }

2
test/test_suite/enumerations/const_enum_with_function_ptr.c3t
View File

@@ -10,7 +10,7 @@ enum Foo : (FooFn f)
BAR { &foo }, // allowed BAR { &foo }, // allowed
} }
const enum Bar : FooFn constdef Bar : FooFn
{ {
FOO = fn int() => 0, // allowed FOO = fn int() => 0, // allowed
BAR = &foo, // Error: Expected an constant enum value. BAR = &foo, // Error: Expected an constant enum value.

8
test/test_suite/enumerations/enum_const.c3t
View File

@@ -2,13 +2,13 @@
module test; module test;
import std; import std;
const enum Bar : String constdef Bar : String
{ {
XABC = "foekf", XABC = "foekf",
XDEF = "foekfokef" XDEF = "foekfokef"
} }
const enum Foo : int constdef Foo : int
{ {
ABC = 4, ABC = 4,
DEF, DEF,
@@ -18,7 +18,7 @@ const enum Foo : int
} }
const enum Bde2 : int constdef Bde2 : int
{ {
FOO = 2, FOO = 2,
BAR = 100 BAR = 100
@@ -30,7 +30,7 @@ const BDE3_BAR = 100;
const enum Abc2 : int constdef Abc2 : int
{ {
UP, UP,
DOWN, DOWN,

2
test/test_suite/enumerations/enum_const_inline_interface.c3
View File

@@ -12,7 +12,7 @@ fn void Foo.x(&self) @dynamic
io::printn("Foo!"); io::printn("Foo!");
} }
const enum Tester : inline Foo constdef Tester : inline Foo
{ {
ABC = 1 ABC = 1
} }

2
test/test_suite/enumerations/enum_const_resolution_order.c3t
View File

@@ -8,7 +8,7 @@ struct Foo
module bar; module bar;
const enum MyEnum : CInt constdef MyEnum : CInt
{ {
VAL1 = 1, VAL1 = 1,
VAL2 = 2, VAL2 = 2,

2
test/test_suite/enumerations/enum_no_inline_property.c3
View File

@@ -1,5 +1,5 @@
module test; module test;
const enum MyEnum : inline short constdef MyEnum : inline short
{ {
ITEM1, ITEM1,
ITEM2, ITEM2,

2
test/test_suite/enumerations/recursive_const_enum.c3
View File

@@ -2,7 +2,7 @@ module main;
faultdef F; faultdef F;
const enum Foo : fault constdef Foo : fault
{ {
F = F // #error: Recursive resolution of expression F = F // #error: Recursive resolution of expression
} }

2
test/test_suite/expressions/casts/inline_to_underlying.c3t
View File

@@ -6,7 +6,7 @@ enum Foo : inline int
{ {
ABC, ABC,
} }
const enum Bar : inline int constdef Bar : inline int
{ {
HELLO = 1 HELLO = 1
} }

2
test/unit/stdlib/collections/linked_map.c3
View File

@@ -186,7 +186,7 @@ enum Foobar : inline char
BAZ BAZ
} }
const enum Foobar2 : inline int constdef Foobar2 : inline int
{ {
ABC = 3, ABC = 3,
DEF = 5, DEF = 5,

2
test/unit/stdlib/collections/map.c3
View File

@@ -63,7 +63,7 @@ enum Foobar : inline char
BAZ BAZ
} }
const enum Foobar2 : inline int constdef Foobar2 : inline int
{ {
ABC = 3, ABC = 3,
DEF = 5, DEF = 5,