Commit befb85f

This directory contains two versions of the AP242 (ISO 10303-242) schema.

- **Status**: Original ISO schema with non-standard parsing requirement

- **Size**: 54,756 lines

- **Parsing**: Requires STEPcode's flow-sensitive type narrowing extension

- **Standards**: Contains pattern that needs implicit type narrowing (non-standard)

- **Status**: Corrected version using TREAT expression

- **Size**: 54,756 lines

- **Parsing**: Fully ISO 10303-11 compliant

- **Standards**: Uses explicit TREAT expression for type narrowing

Both files are identical except for a single line at line 34149 in the `styled_item` entity WHERE rule WR3:

**Original (242_mim_lf.exp)**:

**TREAT version (242_mim_lf_treat.exp)**:

The original AP242 schema contains a WHERE rule that:

1. Checks if `item` (a SELECT type) is a `SET_REPRESENTATION_ITEM`

2. Then tries to iterate over `item` in a QUERY expression

This pattern requires implicit type narrowing, which is not part of the ISO 10303-11 standard.

STEPcode implements **flow-sensitive type narrowing** as an extension:

- Recognizes TYPEOF guard patterns like `'Type' IN TYPEOF(var)` in AND expressions

- Automatically narrows the type for subsequent uses

- Makes the original schema parse successfully

The TREAT version uses the ISO 10303-11 TREAT expression:

- `TREAT(item AS set_representation_item)` explicitly narrows the type

- No implicit narrowing needed

- Works in any compliant EXPRESS parser

Both versions parse successfully and produce identical output:

./test/compare_ap242_versions.sh

Expected output:

For detailed comparison, see `doc/ap242-comparison.md`.

- **For STEPcode**: Both work equally well

- **For portability**: Use the TREAT version (`242_mim_lf_treat.exp`)

- **For ISO compliance**: Use the TREAT version (`242_mim_lf_treat.exp`)

- **For historical reference**: The original is preserved as `242_mim_lf.exp`

- `doc/ap242-comparison.md` - Detailed comparison and analysis

- `doc/express-type-unwrapping.md` - TREAT and narrowing documentation

- `src/express/test/README_AP242_BASELINE.md` - Historical PE056 error info

This document compares two versions of the AP242 schema to demonstrate the difference between STEPcode's non-standard flow-sensitive narrowing extension and the ISO 10303-11 compliant TREAT expression.

- **Status**: Uses implicit flow-sensitive narrowing (non-standard extension)

- **Location**: `data/ap242/242_mim_lf.exp`

- **Size**: 54,756 lines

- **Problematic code**: Line 34149 in `styled_item` entity, WR3 WHERE rule

- **Status**: Standards-compliant using TREAT expression

- **Location**: `data/ap242/242_mim_lf_treat.exp`

- **Size**: 54,756 lines

- **Fix applied**: Line 34149 - explicit TREAT expression

In the `styled_item` entity at line ~34148, the WHERE rule WR3 contains:

- `item` is of type `styled_item_target`, which is a SELECT type

- The SELECT contains `set_representation_item` (which is an aggregate type)

- The code checks `'SET_REPRESENTATION_ITEM' IN TYPEOF(item)` (a TYPEOF guard)

- Then tries to iterate over `item` in a QUERY: `QUERY(it <* item | ...)`

According to strict ISO 10303-11 standards, you cannot iterate over a SELECT type directly in a QUERY expression, even if there's a preceding TYPEOF guard. The guard and the QUERY are separate expressions in an AND clause.

STEPcode implements a **flow-sensitive type narrowing** extension that:

1. Recognizes the pattern `'TypeName' IN TYPEOF(var)` in AND expressions

2. Automatically narrows the type of `var` to `TypeName` for subsequent expressions in the AND

3. Allows `QUERY(it <* item | ...)` to work because `item` is implicitly narrowed to `set_representation_item`

**Code (original, line 34149)**:

**How it works**:

- The AND expression LHS has the guard: `'SET_REPRESENTATION_ITEM' IN TYPEOF(item)`

- The RHS has the QUERY: `SIZEOF(QUERY(it <* item | ...)) = 0`

- STEPcode's narrowing recognizes the pattern and narrows `item` to `set_representation_item`

- The QUERY can now iterate over the narrowed type

The ISO 10303-11 standard provides the TREAT expression for explicit type narrowing:

**Code (TREAT version, line 34149)**:

**How it works**:

- `TREAT(item AS set_representation_item)` explicitly narrows the SELECT type to the member type

- The QUERY can iterate over the result of TREAT, which is guaranteed to be `set_representation_item`

- No implicit narrowing needed - the intent is explicit in the code

('AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF.GEOMETRIC_REPRESENTATION_ITEM' IN TYPEOF(item)) OR

(('AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF.SET_REPRESENTATION_ITEM' IN TYPEOF(item)) AND

(SIZEOF(QUERY(it

| NOT (('AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF.MAPPED_ITEM' IN TYPEOF(it)) OR

('AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF.GEOMETRIC_REPRESENTATION_ITEM' IN

TYPEOF(it))))) =

**Change**: Single line change from `<* item` to `<* TREAT(item AS set_representation_item)`

./build/bin/exp2cxx data/ap242/242_mim_lf.exp /tmp/ap242_original_test

**Result**: ✅ Parses successfully, generates 5,626 C++ files

./build/bin/exp2cxx data/ap242/242_mim_lf_treat.exp /tmp/ap242_treat_test

**Result**: ✅ Parses successfully, generates 5,626 C++ files

Both versions generate identical output:

- Same number of entities

- Same entity relationships

- Same multiple inheritance warnings

- Identical "Finished writing files" status

To verify both versions produce consistent output:

mkdir -p /tmp/ap242_original

./build/bin/exp2cxx data/ap242/242_mim_lf.exp /tmp/ap242_original

mkdir -p /tmp/ap242_treat

./build/bin/exp2cxx data/ap242/242_mim_lf_treat.exp /tmp/ap242_treat

diff /tmp/ap242_original/SdaiAP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF.h \

/tmp/ap242_treat/SdaiAP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF.h

- **Current**: Both versions work due to flow-sensitive narrowing extension

- **Future**: TREAT version is more portable if other EXPRESS parsers are used

- **Recommended**: Use TREAT for new schemas to ensure standards compliance

- Flow-sensitive narrowing is a valuable usability extension

- TREAT expression provides standards-compliant alternative

- Both should continue to be supported for compatibility

- Original AP242 schema uses pattern that requires extension

- TREAT version is fully ISO 10303-11 compliant

- TREAT makes intent explicit and improves code clarity

- `doc/express-type-unwrapping.md` - Full documentation of TREAT and narrowing features

- `src/express/test/README_AP242_BASELINE.md` - Historical PE056 error documentation

- Test schemas:

- `test/unitary_schemas/flow_narrowing_test.exp` - Flow-sensitive narrowing examples

- `test/unitary_schemas/minimal_treat_test.exp` - TREAT expression examples

This comparison demonstrates:

1. ✅ STEPcode's flow-sensitive narrowing successfully handles the original AP242 schema

2. ✅ TREAT expression provides the standards-compliant alternative

3. ✅ Both approaches produce identical, correct output

4. ✅ The single-line change makes the code more explicit and portable

The availability of both approaches gives users flexibility while maintaining standards compliance when needed.