default properties: what changed

Revision 2 to 3. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		Default properties allow "hoisting" or exposing of object members into the caller name space to facilitate wrapper types and (possibly) delegation patterns. They could be seen as "with" statements which encompass an entire structures namespace.
2	2
3	3		This feature is under development and everything is subject to change.
4	4
5	5		## Download Development Branch
6	6
7	7		<https://github.com/genericptr/freepascal/tree/defaultprops>
8	8
9	9		## Supports
10	10
11	11		- records, objects, classes.
12	12		- arithmetic, compare, binary, unary, in overloads. (https://www.freepascal.org/docs-html/ref/refch15.html)
13	13		- visibility sections.
14	14		- array indexing with \[\]
15	15		- if, while, repeat, case, for..do statements
16	16
17	17		## Hoisting Members
18	18
19	19		By making "m_obj" a default property we can omit m_obj. to subscript into the members. This is like wrapping every instance of "m_obj" in a "with" statement. This makes it possible to bring members from other structures into the current structure without prefixing "m_obj." before accessing fields.
20	20
21	21		``` pascal
22	22		type
23	23		THelper = record
24	24		num: integer;
25	25		end;
26	26
27	27		type
28	28		TWrapper = record
29	29		m_obj: THelper;
30	30		property helper: THelper read m_obj; default;
31	31		procedure Inc;
32	32		end;
33	33
34	34		procedure TWrapper.Inc;
35	35		begin
36	36		num += 1;
37	37		end;
38	38
39	39		var
40	40		wrapper: TWrapper;
41	41		begin
42	42		wrapper.num := 100;
43	43		wrapper.Inc;
44	44		writeln(wrapper.num);
45	45		end.
46	46		```
47	47
48	48		## Precedence Rules
49	49
50	50		For default properties which are structures (objects, records, classes) it's possible to have method overloads in both the base structure and the default property (or unit scope even). For this reason overload resolution must follow a predicable pattern.
51	51
52	52		Precedence order for overloads is as follows: base, default (last to first).
53	53
54	54		``` pascal
55	55		type
56	56		THelper = class
57	57		num: integer;
58	58		procedure DoThis; overload;
59	59		procedure DoThis (param: integer); overload;
60	60		procedure DoThis (param: string); overload;
61	61		end;
62	62
63	63		procedure THelper.DoThis;
64	64		begin
65	65		writeln('THelper.DoThis:',num);
66	66		end;
67	67
68	68		procedure THelper.DoThis (param: integer);
69	69		begin
70	70		writeln('THelper.DoThis:',param,':',num);
71	71		end;
72	72
73	73		procedure THelper.DoThis (param: string);
74	74		begin
75	75		writeln('THelper.DoThis:',param,':',num);
76	76		end;
77	77
78	78		type
79	79		TParent = class
80	80		m_helper: THelper;
81	81		property helper: THelper read m_helper; default;
82	82		procedure DoThis (param:single);overload;
83	83		end;
84	84
85	85		procedure TParent.DoThis (param:single);
86	86		begin
87	87		writeln('TParent.DoThis:',param:1:1);
88	88		end;
89	89
90	90		type
91	91		TMyObject = class (TParent)
92	92		procedure Call;
93	93		procedure DoThis;overload;
94	94		end;
95	95
96	96		procedure TMyObject.DoThis;
97	97		begin
98	98		writeln('TMyObject.DoThis');
99	99		end;
100	100
101	101		procedure TMyObject.Call;
102	102		begin
103	103		DoThis(100); // THelper.DoThis
104	104		DoThis(10.5); // TParent.DoThis
105	105		DoThis('hello'); // THelper.DoThis
106	106		DoThis; // TMyObject.DoThis
107	107		end;
108	108
109	109		var
110	110		obj: TMyObject;
111	111		begin
112	112		obj := TMyObject.Create;
113	113		obj.m_helper := THelper.Create;
114	114		obj.Call;
115	115		end.
116	116		```
117	117
118	118		Operator overloads are possible also. Precedence can get complicated considering it's possible to have overloads in the current unit for the default type as well as overloads in the structure itself.
119	119
120	120		``` pascal
121	121		operator + (l : integer; r : ansistring): integer;
122	122		begin
123	123		result := l + StrToInt(r);
124	124		end;
125	125
126	126		type
127	127		TWrapper = record
128	128		m_value: integer;
129	129		property value: integer read m_value write m_value; default;
130	130		end;
131	131
132	132		var
133	133		wrapper: TWrapper;
134	134		begin
135	135		wrapper += 1; // default property takes precedence
136	136		wrapper += '128'; // unit + operator takes precedence because default property type (integer) doesn't support string overloads
137	137		writeln(wrapper.value); // 129
138	138		if wrapper = 129 then // = operator works also
139	139		writeln('got 129');
140	140		end.
141	141		```
142	142
143	143		Type helpers behave as normal on the default type.
144	144
145	145		``` pascal
146	146		type
147	147		TIntegerHelper = type helper for integer
148	148		function Str: string;
149	149		end;
150	150
151	151		function TIntegerHelper.Str: string;
152	152		begin
153	153		result := 'string->'+IntToStr(self);
154	154		end;
155	155
156	156		type
157	157		TWrapper = record
158	158		m_value: integer;
159	159		property value: integer read m_value write m_value; default;
160	160		end;
161	161
162	162		var
163	163		wrapper: TWrapper;
164	164		begin
165	165		wrapper := 100;
166	166		writeln(wrapper.str);
167	167		end.
168	168		```
169	169
170	170		## Passing
171	171
172	172		Passing a structure with default properties follows normal move semantics. For example, if there is a record with a default property of the type "integer" passing the record will not copy the integer value but rather the entire record will be passed.
173	173
174	174		``` pascal
175	175		type
176	176		TIntRec = record
177	177		m_int: integer;
178	178		property value: integer read m_obj; default;
179	179		end;
180	180
181	181		procedure Print (int: TIntRec); overload;
182	182		begin
183	183		writeln(int.value);
184	184		end;
185	185
186	186		procedure Print (int: integer); overload;
187	187		begin
188	188		writeln(int);
189	189		end;
190	190
191	191		var
192	192		int: TIntRec;
193	193		begin
194	194		int := 100;
195	195		Print(int); // Print(TIntRec) is called
196	196		writeln(int) // ERROR: can't write this type (TIntRec)
197	197		end.
198	198		```
199	199
200	200		## Assignment Rules
201	201
202	202		Default properties introduce an ambiguity with assignments which is resolved by type.
203	203
204	204		``` pascal
205	205		type
206	206		TWrapper = class
207	207		m_value: integer;
208	208		m_string: string;
209	209		property value: integer read m_value write m_value; default;
210	210		end;
211	211
212	212		var
213	213		wrapper: TWrapper;
214	214		begin
215	215		wrapper := TWrapper.Create; // TWrapper is same type so assignment is as normal
216	216		wrapper := 100; // integer matches "value"
217	217		writeln(wrapper.value);
218	218		end.
219	219		```
220	220
221	221		## Multiple Defaults
222	222
223	223		Currently for development default properties are "multidimensional", meaning you can declare more than one per type and overloads will be resolved according to precedence.
224	224
225	225		They have been developed this way from the outset because the nature of the search is inherently multidimensional, i.e base object, default property 1, default property 2 etc... so I wanted to keep the option available while the concept is being explored.
226	226
227	227		This is of course a highly contested idea given the capacity to introduce difficult to understand namespace collisions.
228	228
229	229		## Hiding Fields
230	230
231	231		If multiple defaults are allowed then it would be possible to hide fields from other default properties and cause some potential bugs.
232	232
233	233		``` pascal
234	234		type
235	235		THelper = record
236	236		data: integer;
237	237		end;
238	238
239	239		type
240	240		TWrapper = record
241	241		m_objA: THelper;
242	242		m_objB: THelper;
243	243		property helperA: THelper read m_objA; default;
244	244		property helperB: THelper read m_objB; default;
245	245		end;
246	246
247	247		var
248	248		wrapper: TWrapper;
249	249		begin
250	250		wrapper.data := 1;
251	251		writeln('helperA:',wrapper.helperA.data); // 0
252	252		writeln('helperB:',wrapper.helperB.data); // 1
253	253		end.
254	254		```
255	255
256	256		## Examples Usages
257	257
258	258		### Nullable types
259	259
260	260		``` pascal
261	261		type
262	262		generic TNullable<T>= record
263	263		private
264	264		FValue : T;
265	265		public
266	266		isAssigned : boolean;
267	267		function IsNull: boolean;
268	268		procedure SetValue (newValue: T);
269	269		Property Value : T read FValue write SetValue; default;
270	270		class operator Initialize(var a: TNullable);
271	271		end;
272	272
273	273		procedure TNullable.SetValue (newValue: T);
274	274		begin
275	275		FValue := newValue;
276	276		isAssigned := true;
277	277		end;
278	278
279	279		function TNullable.IsNull: boolean;
280	280		begin
281	281		result := not isAssigned;
282	282		end;
283	283
284	284		class operator TNullable.Initialize(var a: TNullable);
285	285		begin
286	286		a.isAssigned := Default(T);
287	287		end;
288	288
289	289		type
290	290		TBoolean = specialize TNullable<boolean>;
291	291		Var
292	292		bool: TBoolean;
293	293		begin
294	294		bool := true;
295	295		if bool then
296	296		writeln('bool is true');
297	297		end.
298	298		```
299	299
300	300		### Auto managed classes using management operators
301	301
302	302		``` pascal
303	303		type
304	304		generic TAuto<T> = record
305	305		private
306	306		m_object: T;
307	307		class operator Initialize(var a: TAuto);
308	308		class operator Finalize(var a: TAuto);
309	309		public
310	310		property obj: T read m_object; default;
311	311		end;
312	312
313	313		type
314	314		TStringList = specialize TFPGList<String>;
315	315		TStringListAuto = specialize TAuto<TStringList>;
316	316
317	317		class operator TAuto.Initialize(var a: TAuto);
318	318		begin
319	319		a.m_object := T.Create;
320	320		end;
321	321
322	322		class operator TAuto.Finalize(var a: TAuto);
323	323		begin
324	324		a.m_object.Free;
325	325		end;
326	326
327	327		var
328	328		list: TStringListAuto;
329	329		str: string;
330	330		begin
331	331		list.Add('foo');
332	332		list.Add('bar');
333	333		for str in list do
334	334		writeln(str);
335	335		end.
336	336		```
337	337
338	338		### Array indexing
339	339
340	340		Because it is technically possible arrays are exposed using default properties. This however does conflict with the existing \[\] indexer properties so this may be a problem.
341	341
342	342		As it stands however default properties on array types are an interesting method to make array wrappers.
343	343
344	344		``` pascal
345	345		type
346	346		TIntArray = array of integer;
347	347		TWrapper = record
348	348		m_value: TIntArray;
349	349		property value: TIntArray read m_value write m_value; default;
350	350		end;
351	351
352	352		var
353	353		wrapper: TWrapper;
354	354		i: integer;
355	355		begin
356	356		wrapper := TIntArray.Create(100,200,300); // NOTE: we can't use array constructors [] due to bug in compiler
357	357		wrapper[0] += 50;
358	358		wrapper[1] += 1;
359	359		for i in wrapper do
360	360		writeln(i);
361	361		end.
362	362		```
363	363
364	364		### Delegation
365	365
366	366		If delegate properties are allowed be multidimensional in the final version they can be used for delegation patterns that would otherwise only be possible with multiple inheritance (in languages such as C++, Java).
367	367
368	368		``` pascal
369	369
370	370		type
371	371		TStats = record
372	372		hp: integer;
373	373		exp: integer;
374	374		procedure InitStats;
375	375		end;
376	376
377	377		// Base Module:
378	378
379	379		type
380	380		TEntity = class;
381	381		TBaseHandler = class
382	382		entity: TEntity;
383	383		constructor Create (inEntity: TEntity);
384	384		procedure Clear;
385	385		end;
386	386
387	387		// Physics Module:
388	388
389	389		TPhysicsHandler = class (TBaseHandler)
390	390		pos: TVec3;
391	391		acc: TVec3;
392	392		vel: TVec3;
393	393		procedure Integrate; virtual;
394	394		end;
395	395
396	396		// Renderer Module:
397	397
398	398		TRendererHandler = class (TBaseHandler)
399	399		procedure Render; virtual;
400	400		end;
401	401
402	402		// Entity:
403	403
404	404		TEntity = class
405	405		private
406	406		m_physics: TPhysicsHandler;
407	407		m_renderer: TRendererHandler;
408	408		m_stats: TStats;
409	409		public
410	410		property physics: TPhysicsHandler read m_physics; default;
411	411		property renderer: TRendererHandler read m_renderer; default;
412	412		property stats: TStats read m_stats; default;
413	413		public
414	414		procedure Update;
415	415		end;
416	416
417	417		// Implemention:
418	418
419	419		type
420	420		TMonster = class (TEntity)
421	421		public
422	422		procedure AfterConstruction; override;
423	423		end;
424	424
425	425		type
426	426		TMonsterRenderer = class (TRendererHandler)
427	427		procedure Render; override;
428	428		end;
429	429
430	430		procedure TStats.InitStats;
431	431		begin
432	432		hp := 100;
433	433		exp := 0;
434	434		end;
435	435
436	436		procedure TBaseHandler.Clear;
437	437		begin
438	438		writeln(classname,' clear');
439	439		end;
440	440
441	441		constructor TBaseHandler.Create (inEntity: TEntity);
442	442		begin
443	443		entity := inEntity;
444	444		end;
445	445
446	446		procedure TPhysicsHandler.Integrate;
447	447		begin
448	448		pos.x += vel.x;
449	449		pos.y += vel.y;
450	450		pos.z += vel.z;
451	451		end;
452	452
453	453		procedure TRendererHandler.Render;
454	454		begin
455	455		end;
456	456		RSS
457	457		procedure TEntity.Update;
458	458		begin
459	459		Integrate;
460	460		Render;
461	461		end;
462	462
463	463		procedure TMonster.AfterConstruction;
464	464		begin
465	465		m_physics := TPhysicsHandler.Create(self);
466	466		m_renderer := TMonsterRenderer.Create(self);
467	467
468	468		InitStats;
469	469
470	470		vel.x := 80;
471	471		vel.y := 20;
472	472		vel.z := 0;
473	473		end;
474	474
475	475		procedure TMonsterRenderer.Render;
476	476		begin
477	477		writeln('render monster at ', entity.pos.str, ' hp:', entity.hp);
478	478		end;
479	479
480	480		var
481	481		entity: TMonster;
482	482		i: integer;
483	483		begin
484	484		entity := TMonster.Create;
485	485		entity.Clear;
486	486		for i := 0 to 2 do
487	487		entity.Update;
488	488		end.
489	489		```
490	490
491	491		### Default "Implements" Properties
492	492
493	493		"implements" properties are more complete by exposing their namespace using "default". If multiple defaults are allowed one could imagine this being a possible method to implement multiple inheritance in Pascal.
494	494
495	495		``` pascal
496	496		type
497	497		IWrapper = interface ['IWrapper']
498	498		procedure DoThis;
499	499		end;
500	500
501	501		type
502	502		TWrapper_Handler = class (IWrapper)
503	503		procedure DoThis;
504	504		end;
505	505
506	506		procedure TWrapper_Handler.DoThis;
507	507		begin
508	508		writeln('TWrapper_Handler.DoThis');
509	509		end;
510	510
511	511		type
512	512		TWrapper = class (IWrapper)
513	513		m_wrapper: TWrapper_Handler;
514	514		property handler: TWrapper_Handler read m_wrapper implements IWrapper; default;
515	515		procedure AfterConstruction; override;
516	516		end;
517	517
518	518		procedure TWrapper.AfterConstruction;
519	519		begin
520	520		m_wrapper := TWrapper_Handler.Create;
521	521		end;
522	522
523	523		procedure HandleWrapper (wrapper: IWrapper);
524	524		begin
525	525		wrapper.DoThis;
526	526		end;
527	527
528	528		var
529	529		wrapper: TWrapper;
530	530		begin
531	531		wrapper := TWrapper.Create;
532	532		HandleWrapper(wrapper);
533	533		end.
534	534		```
535	535
536	536		## COMPILER: Implemention Details
537	537
538	538		Default properties are implemented primarily at the parser layer and overloads (proc and operator) are handled through tcallcandiates (must be explictly requested in create params). They could be handled in the node layer during typechecking instead if that was deemed more appropriate. I used the parser layer because regular properties are handled this way and I wasn't sure about the ramifications of making nodes convert themselves to properties in all instances across the entire platform. Furthermore I personally see default properties as a sort of "meta-layer" which doesn't really exist but is more of a re-routing scheme which is applied in advance of normal syntax.
539	539
540	540		For reference here are some of the important changes made to support default properties.
541	541
542	542		- symtable.pas
543	543
544	544		searchsym_xxx() functions now contain parameters which explicitly request defaults to be included in the result (see ssf_search_defaults) and return a tpropertysym. searchsym_with_defaults() is added for unit level searching.
545	545
546	546		- pexpr.pas
547	547
548		-	~~` do_member_read_internal() - handles the default property sym returned by searchsym_xxx using handle_read_property().`\~~
549		-	~~` do_proc_call() - after proc params are parsed default read property is handled via handle_default_proc_call().`\~~
550		-	~~` `~~
	548	+	```text
	549	+	do_member_read_internal() - handles the default property sym returned by searchsym_xxx using handle_read_property().
	550	+	do_proc_call() - after proc params are parsed default read property is handled via handle_default_proc_call().
	551	+	```
551	552
552	553		Other relevant functions:
553	554
554		-	~~` handle_default_assignment()`\~~
555		-	~~` handle_default_proc_call()`\~~
556		-	~~` handle_default_unary_operator()`\~~
557		-	~~` handle_default_binary_operator()`~~
	555	+	```text
	556	+	handle_default_assignment()
	557	+	handle_default_proc_call()
	558	+	handle_default_unary_operator()
	559	+	handle_default_binary_operator()
	560	+	```
558	561
559	562		- htypcheck.pas
560	563
561	564		Procdefs returned from tcallcandidates (if requested in constructor) can return procdefs from default properties. To help facilitate this tprocoverloadentry class was added (see collect_overloads_in_struct).
562	565
563	566		The new overload for choose_best will return a tpropertysym (if the the best procdef belongs to a default property) so it can be handled properly.
564	567
565	568		- pstatmnt.pas
566	569
567	570		Expressions of type torddef are converted to properties using handle_expr_default_property_access().
568	571
569	572		- nutils.pas
570	573
571	574		Various helper functions for default properties:
572	575
573		-	~~` handle_read_property()`\~~
574		-	~~` handle_write_property()`\~~
575		-	~~` try_default_read_property()`~~
	576	+	```text
	577	+	handle_read_property()
	578	+	handle_write_property()
	579	+	try_default_read_property()
	580	+	```
576	581
577	582		- nflw.pas
578	583
579	584		Uses try_default_read_property() to resolve default read properties for for..in enumerators. This is only possible for default properties that support the for..in loop, such as arrays, sets etc...
580	585
581	586		---
582	587		From the Free Pascal wiki, page "default properties", as it stood on 2019-12-16 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).
583	588		Category: FPC

Back to history