Changeset 81e768d for src/Validate

Timestamp:

Nov 28, 2024, 4:34:08 PM (8 weeks ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

master

Children:

46c4dea

Parents:

f5e37a4

Message:

Fix #276; add support for c-array parameters using dependent lengths.

Without this fix, declarations like

void f( int m, int n, float[m][n] );

would either

• generate bad C code, with unmangled variable names appearing in the function definition, or
• refuse to resolve a valid-c call of such a function.

tests/array-collections/c-dependent: add direct tests of such cases
tests/tuplearray: activate and expand cases which were blocked on #276
tests/array: activate case fm5y, which was blocked on #276; [noise] adjust source line numbers in .expect
tests/typedefRedef: expand coverage of "error, an array detail is different" cases; [noise] adjust source line numbers in .expect
tests/functions: [noise] adjust .expect to have resolved array sizes (extra casts) in the diffed code dump

The fix is:

• (ResolvExpr/ResolveTypeof?, ResolvExpr/Resolver?) Resolve the dimension expressions, where they were missed.
• (ResolvExpr/Resolver?) Prevent dimension expressions that are bound to other parameters from escaping in the function's type, to where they are out of scope. In the f example above, redact the type shown to callers from void (*)(int, int, float[m][n]) to void (*)(int, int, float[][*]).
• (ResolvExpr/Unify?) Relax the matching rules for such a type, when used at a call site, letting the patameters wildcard type match with the concrete type in scope at the caller's side.
• (Validate/ReplaceTypedef?) Apply the former, stricter matching rules to the one place where they are still needed: detecting inconsistent typedefs.

File:

• src/Validate/ReplaceTypedef.cpp (modified) (4 diffs)

src/Validate/ReplaceTypedef.cpp

@@ -120 +120 @@
         }
 }
-
 struct VarLenChecker : public ast::WithShortCircuiting {
         bool result = false;
@@ -126 +125 @@
         void previsit( ast::ArrayType const * at ) { result |= at->isVarLen; }
 };
-
+static bool hasVarLen( const ast::Type * t ) {
+        return ast::Pass<VarLenChecker>::read( t );
+}
+struct ArrayTypeExtractor {
+        std::vector<const ast::ArrayType *> result;
+        void postvisit( const ast::ArrayType * at ) {
+                result.push_back( at );
+        }
+};
+static bool dimensionPresenceMismatched( const ast::Type * t0, const ast::Type * t1) {
+        std::vector<const ast::ArrayType *> at0s = std::move(
+                ast::Pass<ArrayTypeExtractor>::read( t0 ) );
+        std::vector<const ast::ArrayType *> at1s = std::move(
+                ast::Pass<ArrayTypeExtractor>::read( t1 ) );
+        assert( at0s.size() == at1s.size() );
+        for (size_t i = 0; i < at0s.size(); i++) {
+                const ast::ArrayType * at0 = at0s[i];
+                const ast::ArrayType * at1 = at1s[i];
+                assert( ResolvExpr::typesCompatible( at0, at1 ) );
+                if ( (at0->dimension != nullptr) != (at1->dimension != nullptr) ) return true;
+        }
+        return false;
+}
 ast::Decl const * ReplaceTypedefCore::postvisit(
                 ast::TypedefDecl const * decl ) {
@@ -133 +154 @@
                 ast::Type const * t0 = decl->base;
                 ast::Type const * t1 = typedefNames[ decl->name ].first->base;
+                // [hasVarLen]
                 // Cannot redefine VLA typedefs. Note: this is slightly incorrect,
                 // because our notion of VLAs at this point in the translator is
@@ -139 +161 @@
                 // constant/enumerator. The effort required to fix this corner case
                 // likely outweighs the utility of allowing it.
+                // [dimensionPresenceMismatched]
+                // Core typesCompatible logic interprets absent dimensions as wildcards,
+                // i.e. float[][*] matches float[][42].
+                // For detecting incompatible typedefs, we have to interpret them verbatim,
+                // i.e. float[] is different than float[42].
+                // But typesCompatible does assure that the pair of types is structurally
+                // consistent, outside of the dimension expressions.  This assurance guards
+                // the dimension-presence traversal.  So this traversal logic can (and does)
+                // assume that ArrayTypes will be encountered in analogous places.
                 if ( !ResolvExpr::typesCompatible( t0, t1 )
-                                || ast::Pass<VarLenChecker>::read( t0 )
-                                || ast::Pass<VarLenChecker>::read( t1 ) ) {
+                                || hasVarLen( t0 )
+                                || hasVarLen( t1 )
+                                || dimensionPresenceMismatched( t0, t1 ) ) {
                         SemanticError( decl->location, "Cannot redefine typedef %s", decl->name.c_str() );
                 }