026681787a 
					 
					
						
						
							
							cl-interpret: Add a new pretty-debug-printer builtin  
						
						
						
						
					 
					
						2025-01-29 04:16:28 -06:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						80e1219808 
					 
					
						
						
							
							cl-interpret: Tests for new pattern matching behavior  
						
						... 
						
						
						
						TODO: Expand control flow tests 
						
						
					 
					
						2025-01-29 04:15:57 -06:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						6ee9bbd72e 
					 
					
						
						
							
							conlang: PATTERN MATCHING AND DESTRUCTURED BINDINGS WOOOOO  
						
						... 
						
						
						
						- Integrate the Match and Pattern nodes into the AST
  - TODO: `let x: T` is ambiguous with `let x: {}`. Currently the latter takes precedence in the parser.
- Implement pattern matching through unification in the interpreter.
  - It's not fast, but it works!
- Refactor destructuring assignments to use the new pattern functionality 
						
						
					 
					
						2025-01-29 04:15:33 -06:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						d21683ad61 
					 
					
						
						
							
							conlang: Add Quote expression as a hack for testing  
						
						... 
						
						
						
						Possibly removed later, or replaced with something that turns Conlang AST nodes into Conlang data structures. 
						
						
					 
					
						2025-01-29 03:56:19 -06:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						518fbe74a1 
					 
					
						
						
							
							cl-ast: Fix AddrOf misbehavior  
						
						
						
						
					 
					
						2025-01-29 03:31:24 -06:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						5db77db6b8 
					 
					
						
						
							
							cl-interpret: Use dyn dispatch for iterators.  
						
						... 
						
						
						
						- This is a hack because the language has the syntax but no concept of iterators 
						
						
					 
					
						2025-01-28 06:25:04 -06:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						145a24c5ff 
					 
					
						
						
							
							cl-interpret: Assignment 2.0, now with more destructuring!  
						
						... 
						
						
						
						TODO: Destructuring `let`, destructuring patterns in function args..? 
						
						
					 
					
						2025-01-28 06:23:37 -06:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						485afb7843 
					 
					
						
						
							
							cl-interpret: Make ConValues act like value types  
						
						... 
						
						
						
						(Aside from the fact that they're smothered in heap allocations) 
						
						
					 
					
						2025-01-28 06:20:10 -06:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						01871bf455 
					 
					
						
						
							
							cl-interpret: get_line builtin!  
						
						
						
						
					 
					
						2025-01-28 06:14:05 -06:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						fd361f2bea 
					 
					
						
						
							
							cl-interpret: Upvars 2.0  
						
						... 
						
						
						
						- Only captures locals 
						
						
					 
					
						2025-01-28 06:13:38 -06:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						0eef6b910c 
					 
					
						
						
							
							cl-interpret/collect_upvars: elide lifetime  
						
						
						
						
					 
					
						2025-01-23 18:53:07 -06:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						c50940a44c 
					 
					
						
						
							
							cl-interpret: Make an attempt at closures  
						
						... 
						
						
						
						(It kinda sucks, but it emulates closures half decently) 
						
						
					 
					
						2025-01-23 16:23:42 -06:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						883fd31d38 
					 
					
						
						
							
							conlang: Elide lifetimes (fixes clippy lint)  
						
						
						
						
					 
					
						2025-01-16 20:57:33 -06:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						df68d6f2e6 
					 
					
						
						
							
							cl-interpret/tests: Fix broken test  
						
						
						
						
					 
					
						2024-09-19 14:29:21 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						5deb585054 
					 
					
						
						
							
							cl-ast: Add float support  
						
						... 
						
						
						
						- Smuggle floats as integers to maintain `eq`
- This is bad, but not terrible for spec-compliant floats. Might have issues with NaN.
cl_parser: Smuggle floats
cl_interpret: unpack smuggled floats in float literal node 
						
						
					 
					
						2024-09-19 13:20:19 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						fad28beb05 
					 
					
						
						
							
							interpreter: Add float machinery  
						
						... 
						
						
						
						- operators
- type casting 
						
						
					 
					
						2024-09-18 01:02:09 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						8675f91aca 
					 
					
						
						
							
							cl-ast: Remove tail from let (it caused more problems that it could've solved)  
						
						
						
						
					 
					
						2024-07-31 03:19:20 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						97808fd855 
					 
					
						
						
							
							cl-parser: Transliterate to a trait-based parsing implementation  
						
						... 
						
						
						
						Bump version number. 
						
						
					 
					
						2024-07-31 01:39:00 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						388a69948e 
					 
					
						
						
							
							Revert "cl-ast: Unify break, return, and unary expressions"  
						
						... 
						
						
						
						This reverts commit adb0fd229c 
						
						
					 
					
						2024-07-30 22:31:39 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						adb0fd229c 
					 
					
						
						
							
							cl-ast: Unify break, return, and unary expressions  
						
						
						
						
					 
					
						2024-07-30 20:16:07 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						0e545077c6 
					 
					
						
						
							
							cl-ast: Remove "Continue" struct  
						
						
						
						
					 
					
						2024-07-30 19:42:28 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						b64cc232f9 
					 
					
						
						
							
							cl-ast: Move loop expression into unary exprs (with lowest priority)  
						
						
						
						
					 
					
						2024-07-30 18:21:25 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						b0341f06fd 
					 
					
						
						
							
							cl-ast: Move let into Expr  
						
						
						
						
					 
					
						2024-07-30 18:02:09 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						ecebefe218 
					 
					
						
						
							
							cl-interpret: Knock those modules free!  
						
						
						
						
					 
					
						2024-07-27 22:47:46 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						b2733aa171 
					 
					
						
						
							
							cl-interpret/builtin: Add len builtin as a quick hack to write more interesting programs.  
						
						... 
						
						
						
						This is temporary, I just want a way to get the length of a thing atm. 
						
						
					 
					
						2024-07-27 18:43:03 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						3f5c5480ae 
					 
					
						
						
							
							cl-interpret: [NOT FINAL] Add unicode-aware O(n) string indexing  
						
						
						
						
					 
					
						2024-07-27 18:04:39 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						e43847bbd4 
					 
					
						
						
							
							conlang: Introduce as casting  
						
						... 
						
						
						
						Arbitrary primitive type conversion
Currently implemented as jankily as possible in the interpreter, but it works alright™️  
						
						
					 
					
						2024-07-26 05:26:08 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						b3d62c09aa 
					 
					
						
						
							
							conlang: Self is not a type, it's a path to a type  
						
						
						
						
					 
					
						2024-07-17 15:05:52 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						15c4b89bce 
					 
					
						
						
							
							cl-interpret: builtin.rs whitespace changes  
						
						
						
						
					 
					
						2024-07-11 04:43:25 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						aa7612926e 
					 
					
						
						
							
							cl-interpret: Add format builtin  
						
						... 
						
						
						
						Might as well add some new features to play around with until I rip 'em all out 
						
						
					 
					
						2024-07-11 04:42:36 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						a646a9e521 
					 
					
						
						
							
							cl-interpret: VERY rudimentary support for Const and Static  
						
						
						
						
					 
					
						2024-07-11 03:07:56 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						d692f6bb80 
					 
					
						
						
							
							cl-interpret: Complain, rather than panic, on outlined module  
						
						
						
						
					 
					
						2024-07-11 02:48:35 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						d723f7cece 
					 
					
						
						
							
							cl-interpret: String-building addition  
						
						... 
						
						
						
						Note: This drastically increases the number of symbols. Yeowch. 
						
						
					 
					
						2024-07-09 06:14:44 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						b446677eda 
					 
					
						
						
							
							cl-interpret: Enforce wrapping behavior  
						
						
						
						
					 
					
						2024-07-09 06:13:55 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						0beb121f32 
					 
					
						
						
							
							cl-interpret: Change print to print without newline, add new println builtin  
						
						
						
						
					 
					
						2024-07-09 06:13:05 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						406bfb8882 
					 
					
						
						
							
							cl-interpret: Stop kidding myself, I'll be replacing the interpreter before I get rid of this.  
						
						
						
						
					 
					
						2024-05-19 15:16:22 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						0cc0cb5cfb 
					 
					
						
						
							
							conlang: Remove "Identifier" node  
						
						... 
						
						
						
						It never carried any extra information, and got in the way everywhere it was used. 
						
						
					 
					
						2024-05-19 14:41:31 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						f330a7eaa5 
					 
					
						
						
							
							conlang: Split assignment into plain Assign and assign-with-Modify  
						
						
						
						
					 
					
						2024-05-19 14:31:30 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						8d8928b8a8 
					 
					
						
						
							
							conlang: Struct, tuple member accesses, member function call syntax  
						
						... 
						
						
						
						Currently uses UFCS in the interpreter. This may change after type checking? 
						
						
					 
					
						2024-05-19 13:55:28 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						3fe5916a4f 
					 
					
						
						
							
							cl-ast: Switch from old string interner to new string interner  
						
						... 
						
						
						
						Update cl-parser, et. al. to match. 
						
						
					 
					
						2024-04-27 20:24:11 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						40ec9b30e4 
					 
					
						
						
							
							conlang: Use interned strings (Sym) for all symbols  
						
						
						
						
					 
					
						2024-04-24 19:34:29 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						5341631781 
					 
					
						
						
							
							conlang: Add constructor expression for structs!  
						
						... 
						
						
						
						grammar:
- Add new rules `PathLike`, `Structor`, `Fielder`
- Replace Path with PathLike in Primary expressions
cl-ast:
- Add nodes for Structor and Fielder
cl-parser:
- Add branch to path-expression parsing
- Parse Structor bodies
interpret:
- Add TODO 
						
						
					 
					
						2024-04-20 15:02:16 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						efd442bbfa 
					 
					
						
						
							
							conlang: Import items into scope with use!  
						
						... 
						
						
						
						grammar:
- Improve specification of `Path`
- Add `Use` and `UseTree` rules
- Add `Use` as a variant of ItemKind
cl-token:
- Add new keywords `use` and `as`
cl-ast:
- Add nodes for Use and UseTree
- Add new ItemKind for Use
- Implement traversal in Visit and Fold
cl-interpret:
- Mark ItemKind::Use with a todo
cl-parser:
- Update to match grammar
cl-typeck:
- Update to match changes in AST
- Mark UseTrees as NameCollectable and TypeResolvable, but leave as todos 
						
						
					 
					
						2024-04-20 14:51:54 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						9dc0cc7841 
					 
					
						
						
							
							cl-interpret: Give the interpreter a little love  
						
						... 
						
						
						
						And stop copying strings around. 
						
						
					 
					
						2024-04-19 10:49:25 -05:00 
						 
				 
			
				
					
						
					 
					
						
						
							
						
						90a3818ca0 
					 
					
						
						
							
							conlang: Move all cl-libs into the compiler directory  
						
						
						
						
					 
					
						2024-04-19 07:39:23 -05:00