working Decl overhaul

progress on Attributes (global attrs, parent attrs, effective attrs)

Author: sor

Documentation/almost_never_auto.txt

@@ -145,7 +145,5 @@ Contrary to C++, the initialization with the = sign can now communicate its type
 The new can not deduce ...??
 
 
-[magic-return-val=ret]
-[magic-param-val=other]
-[magic-param-ref=other]
-[magic-param-ptr=that]
+{
+	"class", "MyClass", ["dispatch=basic"]

Documentation/design_doc_cpp_myll_1.cpp

@@ -15,13 +15,17 @@ std::unordered_map<index_type,data_type> m;
 data_type{index_type} m;
 
 //////////////////////////// BESSER:
-MyLang		-> C++
-int[16]		-> array<int,16>
-int[*]		-> int *	// pointer that can hold an array
-int*		-> int *	// pointer to a single element
-int[]		-> vector<int>
-int[](16)	-> vector<int>(16)
-int[init:16]-> vector<int>(16)
+MyLang			-> C++
+int[16]			-> array<int,16>
+int[*]			-> int *	// pointer that can hold an array
+int*			-> int *	// pointer to a single element
+int[]			-> vector<int>
+int[](16)		-> vector<int>(16)
+int[](16,99)	-> vector<int>(16,99)
+int[init:16]	-> vector<int>(16)
+int[reserve:16]	-> vector<int> then reserve(16)
+int[>16]		-> vector<int> then reserve(16)
+int[16+]		-> vector<int> then reserve(16)
 
 // compatibility, this from C/C++ is possible
 int@[]		-> int[];
@@ -90,8 +94,8 @@ unique_ptr<BigOne> blah()
 // attributes
 
 linkage = reachability (not accessability)
-[extern,external,global?] var int i;	// extern int i;
-[intern,internal,local?]  var int j;	// static int j;
+[global,extern,external] var int i;	// extern int i;
+[hidden,intern,internal] var int j;	// static int j;
 
 [virtual(forbidden,discouraged,encouraged,enforced), pod == (virtual=forbidden)]
 class X {
@@ -102,3 +106,232 @@ class X {
 [conversion(auto,default,implicit,explicit)]
 ctor( OTHER other) {...}
 
+// rule file myll::magic
+[
+magic_return_val=[ret,result],
+magic_param_val=other,
+magic_param_ref=other,
+magic_param_ptr=that,
+magic_uscore=true,
+magic_autoindex=true,
+convert_decl=true,
+default_on_semicolon=true,
+support_nullptr=warning,
+class_default=[priv,rule_of_n],
+struct_default=[pub,pod],
+method_default=[instance],
+func_default=[global,pure],
+proc_default=[global],
+unique_pointer=std::unique_ptr,
+shared_pointer=std::shared_ptr,
+weak_pointer=std::weak_ptr,
+// static_array: type@[16], dynamic_array@[],
+static_array=std::array,
+dynamic_array=std::vector,
+]
+class rule::myll::magic {}
+
+// rule file myll::retro
+[
+magic_return_val=[],
+magic_param_val=[],
+magic_param_ref=[],
+magic_param_ptr=[],
+magic_uscore=false,
+magic_autoindex=false,
+convert_decl=false,
+default_on_semicolon=false,
+support_nullptr=true,
+class_default=[priv],
+struct_default=[pub],
+method_default=[],
+func_default=[],
+proc_default=[],
+unique_pointer=std::unique_ptr,
+shared_pointer=std::shared_ptr,
+weak_pointer=std::weak_ptr,
+]
+class rule::myll::retro {}
+
+
+[virtual=encouraged]
+class Test
+{
+	field int[*] data;
+	field int size, capacity;
+
+	[dispatch=static, nonvirtual]
+	func
+	{
+		[dispatch=dynamic, virtual]
+		top() => data[size ? size-1 : 0];
+
+		pop() => size && --size;
+	}
+
+	func push( int val )
+	{
+		//if(size+1 < capacity)
+		data[size] = val;
+		++size;
+	}
+
+	[virtual=inherit]
+	class Sub {}
+}
+
+top
+	[dispatch=dynamic, virtual]		// sets to virtual
+	[dispatch=static, nonvirtual]	// applies afterwards, notices overlap and discards
+	[virtual=encouraged]			// applies afterwards, notices overlap and does not disagree
+
+pop
+	[dispatch=static, nonvirtual]	// sets to nonvirtual
+	[virtual=encouraged]			// applies afterwards, notices overlap and does not disagree
+
+push
+	[virtual=encouraged]			// notices no direct setting, applies virtual
+
+different idea
+top
+	[virtual=encouraged] on class saves that child funcs by default should be virtual
+	[dispatch=static, nonvirtual] on func, receives attr from class 	// applies afterwards, notices overlap and discards
+	[dispatch=dynamic, virtual]		// sets to virtual
+
+
+shortcut table
+[final]		class	=>	[dispatch=disallow]	if no virtual base class
+					||	[dispatch=final]	if virtual base class
+[pod]		class	=>	[dispatch=disallow]	=> applies [dispatch=static]	func, among other things
+[interface]	class	=>	[dispatch=interface]=> applies [dispatch=abstract]	func
+[nonvirtual]class	=>	[dispatch=forbid]
+[virtual]	class	=>	[dispatch=basic]	=> applies [virtual] dtor
+[static]	class	=>	[storage=onlystatic]
+[instance]	class	=>	[storage=onlyinstance]
+
+[nonvirtual]func	=>	[dispatch=nonvirtual]
+[abstract]	func	=>	[dispatch=virtual, impl=abstract]
+[virtual]	func	=>	[dispatch=virtual]
+[override]	func	=>	[dispatch=override]
+[final]		func	=>	[dispatch=final]
+
+[manual]	enum	=>	[startcount=nil,counting=manual]
+[]			enum	=>	[startcount=0,	counting=increment]
+[enum]		enum	=>	[startcount=0,	counting=increment]
+[flags]		enum	=>	[startcount=1,	counting=doubling]
+[enum]		enumval	=>	[startcount=???,counting=increment]
+[flags]		enumval	=>	[startcount=???,counting=doubling]
+
+[global]	var		=>	[storage=static]
+
+Dr K sprach grad über seinen Guru, der sowas ist wie ein Coach...
+und dann dachte ich mir ich mache sowas bei unseren neuen Codern,
+vielleicht sollte ich das auch freiberufich machen.
+
+Error ausgeben wenn eine nicht virtuelle klasse implizit zur basisklasse gecastet wird
+
+
+//h
+extern int j;			// visibility external,
+const  int k;			// visibility internal
+extern const int ek;	// visibility external, neet to be extern in h and cpp
+extern const int j;		// visibility external,
+class Blah {
+	static int i;		// storage duration from start to end of program
+	int f() {			// this member function is dispatched statically
+		static int i;	// storage duration from first call to end of program
+		int j = i;		// statically checked that the types are assign-compatible
+	}
+};
+//cpp
+static int i;			// visibility internal, other TU can not see this, maybe not in header?
+int j;
+int Blah::i = 0;
+
+// var in global or NS need to specify one of [module], [global,extenal], [hidden,internal]
+// DO NOT rely on linkage internal/hidden, since merged cpp building might copy multiple files together
+// so a cpp file might have two [internal] var int x; and then fail to compile
+// module linkage can fix this, so rather only use [global] and [module]
+[linkage=module]				var		int mv;	// visibility internal, but since we have merged module builds...
+[linkage=module]				const	int mc;	// visibility internal, ... (fusion of all cpp) this might work
+[hidden,intern(al),NOT static]	var		int hv;	// visibility internal, other TU can not see this
+[hidden,intern(al),NOT static]	const	int hc;	// visibility internal, other TU can not see this
+[global,extern(al),visible]		var		int gv;	// visibility external / global
+[global,extern(al),visible]		const	int gc;	// visibility external / global
+// NOTE: same for functions
+// unnamed NS provide internal linkage
+class Blah {
+	[static,shared,persist(ant)]
+	var int i = 0;	// storage duration from start to end of program
+	func f -> int {			// this member function is dispatched statically
+		[keep,once,static,persistant,prevail,retain]
+		var int i;		// storage duration from first call to end of program
+	}
+};
+int Blah::i = 0;
+
+4 is not the same as +4
+	+4 could be of some type like offset-int, allowing ctors to make a different
+		overload based on this.
+	e.g. Vec<int>(+4) allocates 4 slots more than the default.
+	+-4 could be the same for negative numbers (-4 could already be, if the ctor
+		handles it differently, but still the original type)
+
+how to do explicit template instantiation?
+
+Removed in Myll compared to C and C++ (functionality which was only renamed, is not considered removed)
+- preprocessor (instead use attributes, constexpr)
+- the split between implementation and header files (.cpp/.h/.hpp/...)
+- operator ","
+- operator prefix "+" ???
+- typedef (use using instead)
+- non-class enums (use class enum instead)
+- directly declare an object of a newly declared type (struct B{} b;)
+- local classes, structs, enums, and functions inside functions. (lambdas can replace local functions)
+- forward declarations (import what you need from other modules)
+- assignment in expressions
+- throw in expressions
+- goto
+- unsigned long long and a lot of similar names are gone
+- using {} for initialization everywhere (it solves a problem in C++ which Myll does not have)
+
+
+
+struct B {
+	float x,y,z;
+};
+
+void compute_with_B( B * b ) {
+	...
+}
+
+B b;
+compute_with_B(b);
+
+// top solution is exactly the same as bottom
+// you can only use do_with_B with a object B
+// same as with the solution below
+
+class B {
+	float x,y,z;
+	void compute() {
+		...
+	}
+};
+
+B b;
+b.compute();
+
+// Why do I like namespaces and object bound functions?
+SDL_Renderer render;
+SDL_RenderDrawLine(render, ...);
+
+// If I analyzed that I have no collision with the name Renderer then I could
+// globally add "using Renderer = SDL::Renderer;"
+// or if I'm crazy even "using namespace SDL;"
+SDL::Renderer render;
+render.DrawLine(...); // working autocompletion and 10 significant chars less to write each line
+
+// The code has the same performance as it produces the same binary,
+// assuming that you did not intentionally sabotage DrawLine by making it unnecesarily virtual.
+// This is not about polymorphism.

backend/Core/Attribute.cs

@@ -0,0 +1,116 @@
+namespace Myll.Core
+{
+	public class Attribute
+	{
+		/*
+		public enum Attribute
+		{
+			Auto_Begin,
+			Auto,
+			AutoOn,
+			AutoOff,
+			AutoExplicit,	// if explicitly set to auto
+			Auto_End,
+
+			Preselection_Begin,	// for surrounding areas, ranging from never to always
+			Disallow,
+			Discourage,
+			Manual,		// Needs to be manually set for every applicable child
+			Basic,		// Basic Support, for dispatch this means adding a virtual dtor
+			BasicAuto,	// Basic Support with auto deduction for overridden methods
+			Encourage,
+			Enforce,
+			Preselection_End,
+
+			Yes_Begin,
+			Yes,
+			Pure,
+			Throw,
+			Virtual,
+			Override,
+			Final,
+			Yes_End,
+
+			No_Begin,
+			No,
+			ImPure,
+			NoThrow,
+			NonVirtual,
+			No_End,
+
+			MultiState_Begin,
+			Private,
+			Protected,
+			Public,
+			MultiState_End,
+		}
+		*/
+
+		// TODO merge all of them into one enum?
+		// or split the category parts off?
+		public enum Dispatch : byte {
+			Auto,
+
+			Category_Begin,
+			Forbid,     // all child func NonVirtual (unchangable)
+			Discourage, // all child func NonVirtual
+			Manual,     // all children need explicit specification
+			Encourage,  // all child func Virtual
+			Enforce,    // all child func Virtual (unchangable)
+			Interface,  // all child func Abstract
+			Basic,      // dtor Virtual
+			Abstract,	// dtor PureVirtual but implemented (wtf)
+			Category_End,
+
+			NonVirtual, // Static dispatch, as opposed to Dynamic (Virtual)
+
+			Dynamic_Begin,
+			//Abstract,
+			Virtual,
+			Override,
+			Final,
+			Dynamic_End,
+		}
+
+		public enum Implementation : byte {
+			Auto,
+			Provided, // {...}
+			Abstract, // = 0
+			Default,  // = default
+			Forbid,   // = delete OR Disable
+		}
+
+		// static storage duration and internal linkage
+		public enum Storage : byte {
+			Auto,
+
+			Category_Begin,
+			AllowBoth,
+			OnlyStatic,
+			OnlyStatelessStatic,
+			OnlyInstance,
+			Category_End,
+
+			Static,   // Shared, Persistent, Permanent, Always, Continous
+			Dynamic,  // same as Instance?
+			Instance, // for func, var
+			Thread,   // thread(+static) = internal, thread+extern = external
+		}
+
+		public enum Linkage : byte {
+			Auto,
+			None,     // visible only in its scope
+			Internal, // hides between different TU, Hidden, (Static), prefer Module
+			External, // visible everywhere, Visible, Global
+			Module,   // visible inside the same module, same as Internal for merged compilation
+		}
+
+		public enum Purity : byte {
+			Auto,
+			Impure,
+			Const,     // const this
+			Pure,      // const this and global
+			Constexpr, // same as Pure?
+		}
+	}
+}