Support for structure-valued expressions (#1951)

* Added Type_StructUnknown
* Support for structure-valued expressions

Author: Mihai Budiu

backends/bmv2/common/lower.cpp

@@ -211,7 +211,7 @@ RemoveComplexExpressions::simplifyExpression(const IR::Expression* expression, b
         auto simpl = simplifyExpressions(&si->components);
         if (simpl != &si->components)
             return new IR::StructInitializerExpression(
-                si->srcInfo, si->name, *simpl, si->isHeader);
+                si->srcInfo, si->typeName, si->typeName, *simpl);
         return expression;
     } else {
         ComplexExpression ce;
@@ -316,7 +316,7 @@ RemoveComplexExpressions::postorder(IR::MethodCallExpression* expression) {
             } else if (auto si = arg1->to<IR::StructInitializerExpression>()) {
                 auto list = simplifyExpressions(&si->components);
                 arg1 = new IR::StructInitializerExpression(
-                    si->srcInfo, si->name, *list, si->isHeader);
+                    si->srcInfo, si->typeName, si->typeName, *list);
                 vec->push_back(new IR::Argument(arg1));
             } else {
                 auto tmp = new IR::Argument(

frontends/common/constantFolding.cpp

@@ -581,7 +581,7 @@ const IR::Node* DoConstantFolding::postorder(IR::Member* e) {
                 BUG("Could not find field %1% in type %2%", e->member, type);
             result = CloneConstants::clone(list->components.at(index));
         } else if (auto si = expr->to<IR::StructInitializerExpression>()) {
-            if (si->isHeader && e->member.name == IR::Type_Header::isValid)
+            if (origtype->is<IR::Type_Header>() && e->member.name == IR::Type_Header::isValid)
                 return e;
             auto ne = si->components.getDeclaration<IR::NamedExpression>(e->member.name);
             BUG_CHECK(ne != nullptr, "Could not find field %1% in initializer %2%", e->member, si);

frontends/p4/structInitializers.cpp

@@ -35,8 +35,9 @@ convert(const IR::Expression* expression, const IR::Type* type) {
                 si->push_back(ne);
                 index++;
             }
+            auto type = st->getP4Type()->to<IR::Type_Name>();
             auto result = new IR::StructInitializerExpression(
-                expression->srcInfo, st->name, *si, st->is<IR::Type_Header>());
+                expression->srcInfo, type, type, *si);
             return result;
         } else if (auto sli = expression->to<IR::StructInitializerExpression>()) {
             for (auto f : st->fields) {
@@ -49,8 +50,9 @@ convert(const IR::Expression* expression, const IR::Type* type) {
                 si->push_back(ne);
             }
             if (modified) {
+                auto type = st->getP4Type()->to<IR::Type_Name>();
                 auto result = new IR::StructInitializerExpression(
-                    expression->srcInfo, st->name, *si, st->is<IR::Type_Header>());
+                    expression->srcInfo, type, type, *si);
                 return result;
             }
         }

frontends/p4/toP4/toP4.cpp

@@ -859,10 +859,10 @@ bool ToP4::preorder(const IR::NamedExpression* e) {
 }
 
 bool ToP4::preorder(const IR::StructInitializerExpression* e) {
-    // Currently the P4 language does not have a syntax
-    // for struct initializers, so we use the same syntax as for list expressions.
-    // TODO: this is incorrect if the fields are not in the same order as
-    // in the type.
+    if (e->typeName != nullptr) {
+        visit(e->typeName);
+        builder.append(" ");
+    }
     builder.append("{");
     int prec = expressionPrecedence;
     expressionPrecedence = DBPrint::Prec_Low;
@@ -871,6 +871,8 @@ bool ToP4::preorder(const IR::StructInitializerExpression* e) {
         if (!first)
             builder.append(",");
         first = false;
+        builder.append(c->name.name);
+        builder.append(" = ");
         visit(c->expression);
     }
     expressionPrecedence = prec;

frontends/p4/typeChecking/typeChecker.cpp

@@ -206,8 +206,10 @@ TypeVariableSubstitution* TypeInference::unify(const IR::Node* errorPosition,
     return tvs;
 }
 
-const IR::IndexedVector<IR::StructField>*
-TypeInference::canonicalizeFields(const IR::Type_StructLike* type) {
+const IR::Type*
+TypeInference::canonicalizeFields(
+    const IR::Type_StructLike* type,
+    std::function<const IR::Type*(const IR::IndexedVector<IR::StructField>*)> constructor) {
     bool changes = false;
     auto fields = new IR::IndexedVector<IR::StructField>();
     for (auto field : type->fields) {
@@ -221,9 +223,9 @@ TypeInference::canonicalizeFields(const IR::Type_StructLike* type) {
         fields->push_back(newField);
     }
     if (changes)
-        return fields;
+        return constructor(fields);
     else
-        return &type->fields;
+        return type;
 }
 
 const IR::ParameterList* TypeInference::canonicalizeParameters(const IR::ParameterList* params) {
@@ -492,39 +494,22 @@ const IR::Type* TypeInference::canonicalize(const IR::Type* type) {
         if (changes)
             resultType = new IR::Type_Method(mt->getSourceInfo(), tps, res, pl);
         return resultType;
-    } else if (type->is<IR::Type_Header>()) {
-        auto hdr = type->to<IR::Type_Header>();
-        auto fields = canonicalizeFields(hdr);
-        if (fields == nullptr)
-            return nullptr;
-        const IR::Type* canon;
-        if (fields != &hdr->fields)
-            canon = new IR::Type_Header(hdr->srcInfo, hdr->name, hdr->annotations, *fields);
-        else
-            canon = hdr;
-        return canon;
-    } else if (type->is<IR::Type_Struct>()) {
-        auto str = type->to<IR::Type_Struct>();
-        auto fields = canonicalizeFields(str);
-        if (fields == nullptr)
-            return nullptr;
-        const IR::Type* canon;
-        if (fields != &str->fields)
-            canon = new IR::Type_Struct(str->srcInfo, str->name, str->annotations, *fields);
-        else
-            canon = str;
-        return canon;
-    } else if (type->is<IR::Type_HeaderUnion>()) {
-        auto str = type->to<IR::Type_HeaderUnion>();
-        auto fields = canonicalizeFields(str);
-        if (fields == nullptr)
-            return nullptr;
-        const IR::Type* canon;
-        if (fields != &str->fields)
-            canon = new IR::Type_HeaderUnion(str->srcInfo, str->name, str->annotations, *fields);
-        else
-            canon = str;
-        return canon;
+    } else if (auto hdr = type->to<IR::Type_Header>()) {
+        return canonicalizeFields(hdr, [hdr](const IR::IndexedVector<IR::StructField>* fields) {
+                return new IR::Type_Header(hdr->srcInfo, hdr->name, hdr->annotations, *fields);
+            });
+    } else if (auto str = type->to<IR::Type_Struct>()) {
+        return canonicalizeFields(str, [str](const IR::IndexedVector<IR::StructField>* fields) {
+                return new IR::Type_Struct(str->srcInfo, str->name, str->annotations, *fields);
+            });
+    } else if (auto hu = type->to<IR::Type_HeaderUnion>()) {
+        return canonicalizeFields(hu, [hu](const IR::IndexedVector<IR::StructField>* fields) {
+                return new IR::Type_HeaderUnion(hu->srcInfo, hu->name, hu->annotations, *fields);
+            });
+    } else if (auto su = type->to<IR::Type_UnknownStruct>()) {
+        return canonicalizeFields(su, [su](const IR::IndexedVector<IR::StructField>* fields) {
+                return new IR::Type_UnknownStruct(su->srcInfo, su->name, su->annotations, *fields);
+            });
     } else if (type->is<IR::Type_Specialized>()) {
         auto st = type->to<IR::Type_Specialized>();
         auto baseCanon = canonicalize(st->baseType);
@@ -752,6 +737,20 @@ TypeInference::assignment(const IR::Node* errorPosition, const IR::Type* destTyp
         setType(sourceExpression, destType);
         setCompileTimeConstant(sourceExpression);
     }
+    if (initType->is<IR::Type_UnknownStruct>()) {
+        if (auto ts = destType->to<IR::Type_StructLike>()) {
+            auto si = sourceExpression->to<IR::StructInitializerExpression>();
+            CHECK_NULL(si);
+            bool cst = isCompileTimeConstant(sourceExpression);
+            auto type = new IR::Type_Name(ts->name);
+            sourceExpression = new IR::StructInitializerExpression(
+                type, type, si->components);
+            setType(sourceExpression, destType);
+            if (cst)
+                setCompileTimeConstant(sourceExpression);
+        }
+    }
+
     return sourceExpression;
 }
 
@@ -1522,6 +1521,53 @@ const IR::Node* TypeInference::postorder(IR::Operation_Relation* expression) {
             }
             defined = true;
         } else {
+            auto ls = ltype->to<IR::Type_UnknownStruct>();
+            auto rs = rtype->to<IR::Type_UnknownStruct>();
+            if (ls != nullptr || rs != nullptr) {
+                if (ls != nullptr && rs != nullptr) {
+                    typeError("%1%: cannot compare initializers with unknown types", expression);
+                    return expression;
+                }
+
+                bool lcst = isCompileTimeConstant(expression->left);
+                bool rcst = isCompileTimeConstant(expression->right);
+
+                auto tvs = unify(expression, ltype, rtype);
+                if (tvs == nullptr)
+                    // error already signalled
+                    return expression;
+                if (!tvs->isIdentity()) {
+                    ConstantTypeSubstitution cts(tvs, refMap, typeMap, this);
+                    expression->left = cts.convert(expression->left);
+                    expression->right = cts.convert(expression->right);
+                }
+
+                if (ls != nullptr) {
+                    auto l = expression->left->to<IR::StructInitializerExpression>();
+                    CHECK_NULL(l);  // struct initializers are the only expressions that can
+                                    // have StructUnknown types
+                    BUG_CHECK(rtype->is<IR::Type_StructLike>(), "%1%: expected a struct", rtype);
+                    auto type = new IR::Type_Name(rtype->to<IR::Type_StructLike>()->name);
+                    expression->left = new IR::StructInitializerExpression(
+                        expression->left->srcInfo, type, type, l->components);
+                    setType(expression->left, rtype);
+                    if (lcst)
+                        setCompileTimeConstant(expression->left);
+                } else {
+                    auto r = expression->right->to<IR::StructInitializerExpression>();
+                    CHECK_NULL(r);  // struct initializers are the only expressions that can
+                                    // have StructUnknown types
+                    BUG_CHECK(ltype->is<IR::Type_StructLike>(), "%1%: expected a struct", ltype);
+                    auto type = new IR::Type_Name(ltype->to<IR::Type_StructLike>()->name);
+                    expression->right = new IR::StructInitializerExpression(
+                        expression->right->srcInfo, type, type, r->components);
+                    setType(expression->right, rtype);
+                    if (rcst)
+                        setCompileTimeConstant(expression->right);
+                }
+                defined = true;
+            }
+
             // comparison between structs and list expressions is allowed only
             // if the expression with tuple type is a list expression
             if ((ltype->is<IR::Type_StructLike>() &&
@@ -1769,23 +1815,32 @@ const IR::Node* TypeInference::postorder(IR::StructInitializerExpression* expres
         components->push_back(new IR::StructField(c->name, type));
     }
 
-    const IR::Type* structType;
-    if (expression->isHeader)
-        structType = new IR::Type_Header(
-            expression->srcInfo, expression->name, *components);
-    else
-        structType = new IR::Type_Struct(
-            expression->srcInfo, expression->name, *components);
-    auto type = canonicalize(structType);
-    if (type == nullptr)
-        return expression;
-    setType(getOriginal(), type);
-    setType(expression, type);
+    const IR::Type* structType = new IR::Type_UnknownStruct(
+        expression->srcInfo, "unknown struct", *components);
+    structType = canonicalize(structType);
+
+    const IR::Expression* result = expression;
+    if (expression->typeName != nullptr) {
+        // We know the exact type of the initializer
+        auto desired = getTypeType(expression->typeName);
+        if (desired == nullptr)
+            return expression;
+        auto tvs = unify(expression, desired, structType);
+        if (tvs == nullptr)
+            return expression;
+        if (!tvs->isIdentity()) {
+            ConstantTypeSubstitution cts(tvs, refMap, typeMap, this);
+            result = cts.convert(expression);
+        }
+        structType = desired;
+    }
+    setType(getOriginal(), structType);
+    setType(expression, structType);
     if (constant) {
         setCompileTimeConstant(expression);
         setCompileTimeConstant(getOriginal<IR::Expression>());
     }
-    return expression;
+    return result;
 }
 
 const IR::Node* TypeInference::postorder(IR::ArrayIndex* expression) {

frontends/p4/typeChecking/typeChecker.h

@@ -90,11 +90,6 @@ class TypeInference : public Transform {
     bool isCompileTimeConstant(const IR::Expression* expression) const
     { return typeMap->isCompileTimeConstant(expression); }
 
-    template<typename... T>
-    void typeError(const char* format, T... args) const {
-        ::error(ErrorType::ERR_TYPE_ERROR, format, args...);
-    }
-
     // This is needed because sometimes we invoke visitors recursively on subtrees explicitly.
     // (visitDagOnce cannot take care of this).
     bool done() const;
@@ -123,8 +118,9 @@ class TypeInference : public Transform {
      *  Made virtual to enable private midend passes to extend standard IR with custom IR classes.
      */
     virtual const IR::Type* canonicalize(const IR::Type* type);
-    virtual const IR::IndexedVector<IR::StructField>*
-        canonicalizeFields(const IR::Type_StructLike* type);
+    const IR::Type* canonicalizeFields(
+        const IR::Type_StructLike* type,
+        std::function<const IR::Type*(const IR::IndexedVector<IR::StructField>*)> constructor);
     virtual const IR::ParameterList* canonicalizeParameters(const IR::ParameterList* params);
 
     // various helpers
@@ -173,6 +169,10 @@ class TypeInference : public Transform {
     using Transform::postorder;
     using Transform::preorder;
 
+    template<typename... T>
+    static void typeError(const char* format, T... args) {
+        ::error(ErrorType::ERR_TYPE_ERROR, format, args...);
+    }
     static const IR::Type* specialize(const IR::IMayBeGenericType* type,
                                       const IR::Vector<IR::Type>* arguments);
     const IR::Node* pruneIfDone(const IR::Node* node)