Content assist should propose property constants

[lwrage]

Summary

It would be convenient to have property constants that have the correct type proposed in content assist. Currently property constants are not proposed on Ctrl+Space.

Environment

• OSATE Version: 2.6.0
• Operating System: all

[AaronGreenhouse]

Should apply in context of property associations, record fields in property associations, default value in property definition. What else?

[AaronGreenhouse]

Created some test property sets to see what currently happens and think about what we want to have happen.

• I have properties with base types
• I have properties with declared types
• I have types build from other types:
  • lists
  • ranges
  • records
• I have a declared type that is equivalent to a base type

Property set ps1

property set ps1 is
	intProp: aadlinteger applies to (all);
	stringProp: aadlstring applies to (all);
	listProp: list of aadlinteger applies to (all);
	realProp: aadlreal applies to (all);
	
	myTypeProp: ps1::myType applies to (all);
	myRangeProp: ps1::myRange applies to (all);
	myRecordProp: ps1::myRecord applies to (all);
	myIntProp: ps1::myInt applies to (all);
	
	myInt: type aadlinteger;
	myType: type aadlinteger units ps1::myUnits;
	myRange: type range of ps1::myType;
	myRecord: type record (intF: aadlinteger; myTypeF: ps1::myType; myIntF: ps1::myInt;);

	myUnits: type units (a, b => a * 2, c => b * 2);
end ps1;

I created two more property sets that contain property constant declarations. Each property set has one constant that should be compatible with a corresponding property declaration in ps1.

Property set ps2

property set ps2 is
	with ps1;
	
	int1: constant aadlinteger => 1;  -- does this work with myInt?
	string1: constant aadlstring => "string";
	list1: constant list of aadlinteger => (0, 1, 2);
	real1: constant aadlreal => 0.1;
	
	myInt1: constant ps1::myInt => 3;  -- does this work with aadlinteger?
	myType1: constant ps1::myType => 43 c;
	myRange1: constant ps1::myRange => 13 a .. 42 b;
	myRecord1: constant ps1::myRecord => [intF => 1; myTypeF => 3 a; myIntF => 0;];
end ps2;

Property set ps3

property set ps3 is
	with ps1;
	
	int2: constant aadlinteger => 10;  -- does this work with myInt?
	string2: constant aadlstring => "string string";
	list2: constant list of aadlinteger => (00, 10, 20);
	real2: constant aadlreal => 0.01;
	
	myInt2: constant ps1::myInt => 30;  -- does this work with aadlinteger?
	myType2: constant ps1::myType => 430 c;
	myRange2: constant ps1::myRange => 130 a .. 420 b;
	myRecord2: constant ps1::myRecord => [intF => 10; myTypeF => 30 a; myIntF => 100;];
end ps3;

I created a package and another property set to use as test contexts for the content assist menu:

• The package just creates a system with property associations to all the properties from ps1 to test the content assist in a property association.
• The property set duplicates the property declarations from ps1 to test the content assist in place of a default value.
• Both the package and the property set have a record-typed property to test the content assist in the place of record field association.

(The exact property values and default values below are not important)

Package pkg

package pkg
public
	with ps1, ps2, ps3;

	system s
		properties
			ps1::intProp => 1;
			ps1::stringProp => "";
			ps1::listProp => ();
			ps1::realProp => 0.2;
			
			ps1::myIntProp => ps3::myInt2;
			ps1::myTypeProp => ps2::myType1;
			ps1::myRangeProp => ps3::myRange2;
			ps1::myRecordProp => [intF=>1; myTypeF=>ps1::myTypeProp; myIntF=>ps3::myInt2;];
	end s;
end pkg;

Property set ps4

property set ps4 is
	with ps1, ps2, ps3;
	
	intProp: aadlinteger => 1 applies to (all);
	stringProp: aadlstring => ""  applies to (all);
	listProp: list of aadlinteger => (1, 2) applies to (all);
	realProp: aadlreal => 0.0 applies to (all);
	
	myIntProp: ps1::myInt => ps3::myInt2 applies to (all);
	myTypeProp: ps1::myType => ps3::myType2 applies to (all);
	myRangeProp: ps1::myRange => ps3::myRange2 applies to (all);
	myRecordProp: ps1::myRecord => ps3::myRecord2 applies to (all);
end ps4;

To be clear, I am current testing the content assist in four contexts:

1. property association value
2. property constant association value
3. default property value in a property declaration
4. record field value when the record is in a property association or default value

[AaronGreenhouse]

Current behavior of the content assist with property association values:

• For intProp (type aadlinteger) there are no suggested property constants.
  • I think we expect and want ps2::int1, ps3::int2 to be suggested.
  • I think we also expect and want ps2::myInt1, ps3::myInt2 to be suggested. These can be associated to the property without any declarative errors.
• For stringProp (type aadlstring) there are no suggested property constants.
  • I think we expect and want ps2::string1, ps3::string2 to be suggested.
• For listProp (type list of aadlstring) there are no suggested property constants.
  • I think we expect and want ps2::list1, ps3::list2 to be suggested.
• For realProp (type list of aadlreal) there are no suggested property constants.
  • I think we expect and want ps2::real1, ps3::real2 to be suggested.
• For myIntProp (type ps1::myInt) the property constants ps2::myInt1 and ps3::myInt2 are suggested.
  • But strangely the property ps4::myIntProp is also suggested.
  • I think we expect and want ps2::int1, ps3::int2 to be suggested.
  • I think we also expect and want ps2::int1, ps3::int2 to be suggested. These can be associated to the property without any declarative errors.
• For myTypeProp (type ps1::myType) the property constants ps2::myType1 and ps3::myType1 are suggested.
  • But strangely the property ps4::myTypeProp is also suggested.
• For myRangeProp (type ps1::myRange) the property constants ps2::myRange1 and ps3::myRange2 are suggested.
  • But strangely the property ps4::myRangeProp is also suggested.
• For myRecordProp (type ps1::myRecord) the property constants ps2::myRecord1 and ps3::myRecord2 are suggested.
  • But strangely the property ps4::myRecordProp is also suggested.

The behavior is identical In the context of default property value.

Things are slightly different, however, the contexts of property constant association value and record field value:

• For the user declared property types the the declarations from both ps1 and ps4 are suggested.

[AaronGreenhouse]

What we need to do

• We never want to suggest a property declaration. Not sure why sometimes we suggest 0, 1, or 2 property declarations.
• We need to suggest property constants for the base types.

Question

• Do we suggest property constants across compatible types, e.g., aadlinteger and ps1::myInt in this case? Currently the I can mix these up, i.e., associate ps2::int1 with the the property ps1::myIntProp and associate ps3::myInt2 with the property ps1::intProp.

I don't get any errors in the declarative model. I don't see a lot of guidance on this in the AADL spec. Legality rule (L8) for property associations reads:

In a property association, the type of the evaluated property expression must match the property type of the named property.

Legality rule (L3) for property constants reads:

The property type of the property constant declaration must match the property type of the constant property value.

The legality rule (L2) for property expressions reads:

The type of a property named in a property term must be identical to the type of the property name in the property association.

But identical and matching are never defined.

[AaronGreenhouse]

I've looked into why aadlinteger and ps1::myInt accept each other's constant values. The validator does not do any type inference, which is not surprising because that is never defined in the standard. Instead, when testing if a property constant is acceptable to be associated with a property of a given type, the value of the property constant is recursively tested for membership of the property's type. Furthermore, named user-declared types are just aliases, and are replaced with the actual type before the type checking is performed. So, a property whose type is either aadlinteger or ps1::myInt is tested to see that the value being associated with it satisfies aadlinteger.

This tells me that for properties of type aadlinteger and ps1::myInt we do want to suggest the four property constants:

• ps2::int1
• ps3::int2
• ps2::myInt1
• ps3::myInt2

[lwrage]

I'd like to keep this simple, i.e. it should be enough to just propose property constants that have the same type name as what's written in the property definition. So only constants declared as aadlinteger should be proposed where the property definition has aadlinteger. The proposals don't have to be exhaustive, it's enough if we get the obvious candidates.