Merge branch 'develop'

Author: vain0x

.gitignore

@@ -12,8 +12,12 @@ src/libmilonert/hashmap.h
 
 # Generated files.
 *.a
+*.fsi
+*.generated.*
 *.o
+*.obj
 *.out
+*.pdb
 *.so
 .ninja_log
 
@@ -23,6 +27,13 @@ tests/**/build.ninja
 tests/**/MiloneCore_*.c
 tests/**/MiloneDerive_*.c
 tests/**/Std_*.c
+tests/**/*.exe
+tests/*/*/x86_64-unknown-linux-gnu-debug/
+tests/*/*/x86_64-pc-windows-msvc-debug/
+tests/*/*/x86_64-pc-windows-msvc-debug-obj/
+tests/**/*.sln
+tests/**/*.vcxproj
+tests/**/guid.txt
 
 tests/examples/*/*.c
 !tests/examples/factorial/factorial.c
@@ -31,7 +42,6 @@ tests/primitives/std_*/*.c
 
 
 # Deprecated: These rules are no longer used.
-*.generated.*
 *.timestamp
 runtime/hashmap.h
 tests/**/MiloneStd_*.c

CHANGELOG.md

@@ -4,7 +4,39 @@
 
 ## [Unreleased]
 
-[Unreleased]: https://github.com/vain0x/milone-lang/compare/v0.6.0...develop
+[Unreleased]: https://github.com/vain0x/milone-lang/compare/v0.6.1...develop
+
+
+
+## [v0.6.1] - 2024-01-07
+
+[v0.6.1]: https://github.com/vain0x/milone-lang/compare/v0.6.0...develop
+
+This version fixes a build issue. It also provides .NET tool version upgrade and some performance improvement.
+
+### CLI Tools
+
+- (*Windows*) `milone` command now generates VS2022 project files to build C code.
+
+### LSP Server
+
+- Parse results are now memoized
+- Some refactoring
+
+### Internal Changes
+
+Compiler:
+
+- Type synonym expansions is now faster
+- Preparations for workspaces:
+    - Multiple `main` functions are now allowed
+    - (*Windows*) MSBuild backend supports multi-projects
+
+Others:
+
+- Use `--allsig` options in F# projects (to reduce compilation time)
+- Add `scripts/prof` and `docs/internals/profiling.md`
+- Fix build/pack scripts
 
 ## [v0.6.0] - 2023-02-15
 
@@ -19,8 +51,8 @@
 ### Language Features
 
 - Support generic records
-- Fixed type check bugs
-- Fixed unicode string literals broken
+- Fix type check bugs
+- Fix unicode string literals broken
 - Add `never` type
 - Add primitives:
     - Add byte literals (`'a'B` syntax)
@@ -37,7 +69,7 @@
         - `binary staticlib` (`*.a`, `*.lib`)
     - Add `subsystem windows` directive (only on Windows)
 
-## Standard Libraries
+### Standard Libraries
 
 - Add `Std.CStr`, `Std.CMemory` modules for native interop
 - Add `Std.StringBuffer` module

Makefile

@@ -31,18 +31,28 @@ src/libmilonert/hashmap.h:
 # MyBuildTool wrapper
 # ------------------------------------------------
 
-MY_BUILD := src/MyBuildTool/bin/Debug/net6.0/MyBuildTool
+DOTNET_RESTORE_TIMESTAMP := target/.timestamp/dotnet_restore
+
+MY_BUILD := src/MyBuildTool/bin/Debug/net8.0/MyBuildTool
+
 MY_BUILD_TIMESTAMP := target/.timestamp/my_build_tool
 
-.PHONY: dotnet_restore gen2 gen3 integration_tests my_build self test_self
+# Compiler to be used for bootstrapping, built by .NET version.
+# (This will become outdated over development. Delete the file to rebuild.)
+MILONE_BOOTSTRAP := target/bootstrap/bin/milone
+
+# Compiler to be used for testing, built from source files in the worktree with MILONE_BOOTSTRAP.
+MILONE_WORKTREE := target/MiloneCli/bin/milone
 
-target/.timestamp/dotnet_restore: $(wildcard src/*/*.fsproj)
+.PHONY: bootstrap building_tests dotnet_restore my_build self test_self
+
+${DOTNET_RESTORE_TIMESTAMP}: $(wildcard src/*/*.fsproj)
 	dotnet restore && mkdir -p $(shell dirname $@) && touch $@
 
-${MY_BUILD_TIMESTAMP}: target/.timestamp/dotnet_restore \
+${MY_BUILD_TIMESTAMP}: ${DOTNET_RESTORE_TIMESTAMP} \
 		$(wildcard src/MyBuildTool/*.fs) \
 		$(wildcard src/MyBuildTool/*.fsproj)
-	dotnet build -nologo src/MyBuildTool && mkdir -p $(shell dirname $@) && touch $@
+	dotnet build -nologo --no-restore src/MyBuildTool && mkdir -p $(shell dirname $@) && touch $@
 
 my_build: ${MY_BUILD_TIMESTAMP}
 
@@ -55,31 +65,39 @@ uninstall: ${MY_BUILD_TIMESTAMP}
 pack: ${MY_BUILD_TIMESTAMP}
 	${MY_BUILD} pack
 
-target/milone: bin/ninja ${MY_BUILD_TIMESTAMP} \
+${MILONE_BOOTSTRAP}: bin/ninja ${DOTNET_RESTORE_TIMESTAMP}
+	env MILONE_HOME=${PWD} dotnet run --project src/MiloneCli -- build src/MiloneCli --target-dir target/bootstrap -o $@ && touch $@
+
+bootstrap: ${MILONE_BOOTSTRAP}
+
+${MILONE_WORKTREE}: bin/ninja \
+		${MILONE_BOOTSTRAP} \
+		${MY_BUILD_TIMESTAMP} \
 		src/libmilonert/hashmap.h \
 		src/libmilonert/milone.h \
 		src/libmilonert/milone.c \
 		src/libmilonert/milone_platform.c \
 		$(wildcard src/*/*.fs) \
 		$(wildcard src/*/*.fsproj) \
 		$(wildcard src/*/*.milone)
-	${MY_BUILD} gen2 && mkdir -p $(shell dirname $@) && touch $@
-
-gen2: target/milone
+	env MILONE_HOME=${PWD} ${MILONE_BOOTSTRAP} build src/MiloneCli -o $@ && touch $@
 
-target/.timestamp/gen3: bin/ninja ${MY_BUILD_TIMESTAMP} target/milone
-	${MY_BUILD} gen3 && mkdir -p $(shell dirname $@) && touch $@
+worktree: ${MILONE_WORKTREE}
 
-gen3: target/.timestamp/gen3
+target/milone: ${MILONE_WORKTREE}
+	cp ${MILONE_WORKTREE} $@
 
-self: gen2
+# Building tests: Testing by building projects in the tests directory.
+target/.timestamp/building_tests: ${MY_BUILD_TIMESTAMP} ${MILONE_WORKTREE} \
+		$(shell find tests -type f -mtime -1)
+	env MILONE=${MILONE_WORKTREE} ${MY_BUILD} building-tests && mkdir -p $(shell dirname $@) && touch $@
 
-test_self: gen3
+building_tests: target/.timestamp/building_tests
 
-target/.timestamp/integration_tests: bin/ninja ${MY_BUILD_TIMESTAMP} target/milone \
-		$(shell find tests -type f -mtime -1)
-	${MY_BUILD} tests && mkdir -p $(shell dirname $@) && touch $@
+# Self-hosting tests: Testing by running the self-hosted compiler to verify the generated code equality.
+target/.timestamp/self_hosting_tests: ${MY_BUILD_TIMESTAMP} ${MILONE_WORKTREE}
+	 MILONE=${MILONE_WORKTREE} ${MY_BUILD} self-hosting-tests && mkdir -p $(shell dirname $@) && touch $@
 
-integration_tests: target/.timestamp/integration_tests
+self_hosting_tests: target/.timestamp/self_hosting_tests
 
-test: test_self integration_tests
+test: building_tests self_hosting_tests

docs/internals/profiling.md

@@ -0,0 +1,95 @@
+# Profiling
+
+This is a note how to profile the compiler.
+
+## Prerequisites
+
+- Ubuntu (Linux)
+- `gprof` (GNU prof)
+- `python3`
+- `graphviz`
+- [gprof2dot](https://github.com/jrfonseca/gprof2dot), visualizer
+
+```sh
+sudo apt install python3 graphviz
+
+GPROF2DOT='https://raw.githubusercontent.com/jrfonseca/gprof2dot/master/gprof2dot.py'
+curl -sL "$GPROF2DOT" -o ~/.local/bin/gprof2dot && chmod +x ~/.local/bin/gprof2dot
+```
+
+## Script
+
+In a nutshell, do on the repository root:
+
+```sh
+scripts/prof
+```
+
+and `target/prof.png` is generated.
+
+---
+
+## Explanation
+
+> 1\. `make worktree && test -f "$MILONE_CMD"`
+
+We need to have a pre-built milone-lang compiler. Generate one by building the worktree:
+
+> 2\.
+> ```sh
+> CC='gcc -pg' MILONE_HOME=$PWD "$MILONE_CMD" build --release 'src/MiloneCli' --target-dir 'target/MiloneProf' -o 'target/milone-prof'
+> ```
+
+Next, compile the milone-lang compiler with *instrumentation* enabled by passing `-pg` flag to GCC.
+The environment variable `CC` is used to compile C source files internally.
+
+Target directory is modified to another directory (`target/MiloneProf`) than the default one (`target/MiloneCli`).
+This avoids overwriting intermediate object files in that directory.
+
+`-o` is specified to ensure the output executable is available at the specified path.
+
+> 3\.
+> ```sh
+> MILONE_HOME=$PWD target/milone-prof check src/MiloneCli && \
+>     test -f gmon.out && \
+>     mv gmon.out target/gmon.out
+> ```
+
+This runs the compiler built on the previous step.
+As an effect of `-pg` flag, the command will emit an extra file named `gmon.out` on the working directory after successful exit.
+`test` command makes it explicit.
+The following `mv` command move that file to the target directory just because we don't want to scatter files in the repository root and ensure not to commit.
+
+The `gmon.out` file records the profiling data while the command is running.
+Data, what functions are called, how many times they are called, how long they spend time, etc.
+
+> 4\.
+> ```sh
+> gprof target/milone-prof target/gmon.out | \
+>    tee target/prof.txt | \
+>    gprof2dot | \
+>    dot -Tpng -o target/prof.png
+> ```
+
+Finally convert the record to a human-readable format.
+`gprof` command generates a plain text file, which is written to `target/prof.txt`.
+
+`gprof2dot` command converts the text (piped from gprof) to another format called dot language, which describes relationship of entities, i.e.
+a graph that consists of functions and connection from callee ones to callers.
+`dot` command (from graphviz package) converts the dot to a PNG image, which is a visualized form of the profiling data.
+
+#### Legends
+
+In the image, functions are associated with several numbers.
+
+```
+    SomeFun
+     42%
+    (5.3%)
+     64x
+```
+
+- First row (`SomeFun`): Mangled name of the function
+- Second row (`42%`): Total time spent while the function is called, including other functions that it called to
+- Third row (`(5.3%)`): Time spent while the function is called itself, excluding the other functions
+- Last row (`64x`): The number of times the function is called

nursery/.vscode/c_cpp_properties.json

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>

nursery/AppGtk/.vscode/c_cpp_properties.json

@@ -40,8 +40,8 @@ mkdir -p "$MILONE_HOME/src"
 
 # Make symbolic links.
 ln -fs "$PWD/target/milone" "$MILONE_HOME/bin/milone_native"
-ln -fs "$PWD/src/MiloneCli/bin/Debug/net6.0/MiloneCli" "$MILONE_HOME/bin/milone_dotnet/MiloneCli"
-ln -fs "$PWD/src/MiloneLspServer/bin/Debug/net6.0/MiloneLspServer" "$MILONE_HOME/bin/milone_lsp/MiloneLspServer"
+ln -fs "$PWD/src/MiloneCli/bin/Debug/net8.0/MiloneCli" "$MILONE_HOME/bin/milone_dotnet/MiloneCli"
+ln -fs "$PWD/src/MiloneLspServer/bin/Debug/net8.0/MiloneLspServer" "$MILONE_HOME/bin/milone_lsp/MiloneLspServer"
 ln -fs "$PWD/src/libmilonert" "$MILONE_HOME/src/libmilonert"
 ln -fs "$PWD/src/MiloneCore" "$MILONE_HOME/src/MiloneCore"
 ln -fs "$PWD/src/Std" "$MILONE_HOME/src/Std"

nursery/AppGtk/AppGtk.fsproj

@@ -0,0 +1,22 @@
+#!/bin/sh
+# See also internals/profiling.md
+
+set -eux
+
+MILONE_CMD='target/MiloneCli/bin/milone'
+
+# build compiler
+make worktree && test -f "$MILONE_CMD"
+
+# build the optimized compiler with instrumentation enabled (-pg flag)
+CC='gcc -pg' MILONE_HOME=$PWD "$MILONE_CMD" build --release src/MiloneCli --target-dir target/MiloneProf -o target/milone-prof
+
+# run the compiler for profiling
+MILONE_HOME=$PWD target/milone-prof check src/MiloneCli && \
+    test -f gmon.out && \
+    mv gmon.out target/gmon.out
+
+gprof target/milone-prof target/gmon.out | \
+    tee target/prof.txt | \
+    gprof2dot | \
+    dot -Tpng -o target/prof.png