bind more type qualifiers

ltcmelo · Apr 20, 2024 · c3326a0 · c3326a0
1 parent 442231a
commit c3326a0
Show file tree

Hide file tree

Showing 9 changed files with 171 additions and 16 deletions.
diff --git a/C/binder/ConstraintsInTypeSpecifiers.cpp b/C/binder/ConstraintsInTypeSpecifiers.cpp
@@ -74,8 +74,8 @@ void ConstraintsInTypeSpecifiers::specify(SyntaxToken builtTySpecTk,
 }
 
 BuiltinTypeKind ConstraintsInTypeSpecifiers::combine(SyntaxToken builtTySpecTk,
-                                                  BuiltinTypeKind builtTyKind,
-                                                  Binder::DiagnosticsReporter* diagReporter)
+                                                     BuiltinTypeKind builtTyKind,
+                                                     Binder::DiagnosticsReporter* diagReporter)
 {
     const auto tkK = builtTySpecTk.kind();
     switch (builtTyKind) {

diff --git a/C/binder/SemanticsOfTypeQualifiers.cpp b/C/binder/SemanticsOfTypeQualifiers.cpp
@@ -29,6 +29,22 @@
 using namespace psy;
 using namespace C;
 
+const std::string SemanticsOfTypeQualifiers::ID_InvalidUseOfRestrict =
+        "Binder-300-6.7.3-2";
+
+void SemanticsOfTypeQualifiers::InvalidUseOfRestrict(
+        SyntaxToken tyQualTk,
+        Binder::DiagnosticsReporter* diagReporter)
+{
+    diagReporter->diagnose(DiagnosticDescriptor(
+                               ID_InvalidUseOfRestrict,
+                               "[[invalid use of restrict]]",
+                               "invalid use of `restrict'",
+                               DiagnosticSeverity::Error,
+                               DiagnosticCategory::Binding),
+                           tyQualTk);
+}
+
 void SemanticsOfTypeQualifiers::qualify(SyntaxToken tyQualTk,
                                         TypeSymbol* tySym,
                                         Binder::DiagnosticsReporter* diagReporter)
@@ -39,6 +55,21 @@ void SemanticsOfTypeQualifiers::qualify(SyntaxToken tyQualTk,
             tySym->qualifyWithConst();
             break;
 
+        case Keyword_volatile:
+            tySym->qualifyWithVolatile();
+            break;
+
+        case Keyword_restrict:
+            if (tySym->typeKind() == TypeKind::Pointer)
+                tySym->qualifyWithRestrict();
+            else
+                InvalidUseOfRestrict(tyQualTk, diagReporter);
+            break;
+
+        case Keyword__Atomic:
+            tySym->qualifyWithAtomic();
+            break;
+
         default:
             PSY_ESCAPE_VIA_BREAK;
     }

diff --git a/C/binder/SemanticsOfTypeQualifiers.h b/C/binder/SemanticsOfTypeQualifiers.h
@@ -37,10 +37,18 @@ class Binder;
 
 class PSY_C_NON_API SemanticsOfTypeQualifiers
 {
+    friend class BinderTester;
+
 public:
+    static void InvalidUseOfRestrict(SyntaxToken tyQualTk,
+                                     Binder::DiagnosticsReporter* diagReporter);
+
     static void qualify(SyntaxToken tyQualTk,
                         TypeSymbol* tySym,
                         Binder::DiagnosticsReporter* diagReporter);
+
+private:
+    static const std::string ID_InvalidUseOfRestrict;
 };
 
 } // C

diff --git a/C/symbols/Symbol_Type.cpp b/C/symbols/Symbol_Type.cpp
@@ -54,6 +54,11 @@ bool TypeSymbol::isRestrictQualified() const
     return P->BF_.restrict_;
 }
 
+bool TypeSymbol::isAtomicQualified() const
+{
+    return P->BF_.atomic_;
+}
+
 void TypeSymbol::qualifyWithConst()
 {
     P->BF_.const_ = 1;
@@ -69,6 +74,11 @@ void TypeSymbol::qualifyWithRestrict()
     P->BF_.restrict_ = 1;
 }
 
+void TypeSymbol::qualifyWithAtomic()
+{
+    P->BF_.atomic_ = 1;
+}
+
 namespace psy {
 namespace C {
 

diff --git a/C/symbols/Symbol_Type.h b/C/symbols/Symbol_Type.h
@@ -78,26 +78,32 @@ class PSY_C_API TypeSymbol : public Symbol
     TypeKind typeKind() const;
 
     /**
-     * Whether the type is \c const qualified.
+     * Whether \c this type is \c const qualified.
      */
     bool isConstQualified() const;
 
     /**
-     * Whether the type is \c volatile qualified.
+     * Whether \c this type is \c volatile qualified.
      */
     bool isVolatileQualified() const;
 
     /**
-     * Whether the type is \c restrict qualified.
+     * Whether \c this type is \c restrict qualified.
      */
     bool isRestrictQualified() const;
 
+    /**
+     * Whether \c this type is \c _Atomic qualified.
+     */
+    bool isAtomicQualified() const;
+
 PSY_INTERNAL_AND_RESTRICTED:
     PSY_GRANT_ACCESS(SemanticsOfTypeQualifiers);
 
     void qualifyWithConst();
     void qualifyWithVolatile();
     void qualifyWithRestrict();
+    void qualifyWithAtomic();
 
 protected:
     DECL_PIMPL_SUB(TypeSymbol);

diff --git a/C/symbols/Symbol__IMPL__.inc b/C/symbols/Symbol__IMPL__.inc
@@ -59,6 +59,7 @@ struct Symbol::SymbolImpl
         std::uint16_t const_ : 1;
         std::uint16_t volatile_ : 1;
         std::uint16_t restrict_ : 1;
+        std::uint16_t atomic_ : 1;
     };
     union
     {

diff --git a/C/tests/BinderTester_1000_1999.cpp b/C/tests/BinderTester_1000_1999.cpp
@@ -23,6 +23,7 @@
 #include "ParserTester.h"
 
 #include "binder/ConstraintsInTypeSpecifiers.h"
+#include "binder/SemanticsOfTypeQualifiers.h"
 #include "parser/Unparser.h"
 #include "symbols/Symbol.h"
 #include "symbols/Symbol_ALL.h"
@@ -274,11 +275,49 @@ void BinderTester::case1054()
                       .TySpec.basis("x", NamedTypeKind::Synonym, BuiltinTypeKind::UNSPECIFIED, CVR::Const)));
 }
 
-void BinderTester::case1055() {}
-void BinderTester::case1056() {}
-void BinderTester::case1057() {}
-void BinderTester::case1058() {}
-void BinderTester::case1059() {}
+void BinderTester::case1055()
+{
+    bind("int volatile x ;",
+         Expectation()
+             .binding(DeclSummary()
+                      .Value("x", ValueKind::Variable)
+                      .TySpec.basis("int", NamedTypeKind::Builtin, BuiltinTypeKind::Int, CVR::Volatile)));
+}
+
+void BinderTester::case1056()
+{
+    bind("int volatile const x ;",
+         Expectation()
+             .binding(DeclSummary()
+                      .Value("x", ValueKind::Variable)
+                      .TySpec.basis("int", NamedTypeKind::Builtin, BuiltinTypeKind::Int, CVR::ConstAndVolatile)));
+}
+
+void BinderTester::case1057()
+{
+    bind("int restrict x ;",
+         Expectation().diagnostic(
+             Expectation::ErrorOrWarn::Error,
+             SemanticsOfTypeQualifiers::ID_InvalidUseOfRestrict));
+}
+
+void BinderTester::case1058()
+{
+    bind("int const restrict x ;",
+         Expectation().diagnostic(
+             Expectation::ErrorOrWarn::Error,
+             SemanticsOfTypeQualifiers::ID_InvalidUseOfRestrict));
+
+}
+
+void BinderTester::case1059()
+{
+    bind("_Atomic int x ;",
+         Expectation()
+             .binding(DeclSummary().Value("x", ValueKind::Variable)
+                      .TySpec.basis("int", NamedTypeKind::Builtin, BuiltinTypeKind::Int, CVR::Atomic)));
+}
+
 void BinderTester::case1060() {}
 void BinderTester::case1061() {}
 void BinderTester::case1062() {}
@@ -573,7 +612,10 @@ void BinderTester::case1151()
                       .TySpec.deriv(TypeKind::Pointer)));
 }
 
-void BinderTester::case1152() {}
+void BinderTester::case1152()
+{
+}
+
 void BinderTester::case1153() {}
 void BinderTester::case1154() {}
 void BinderTester::case1155() {}
@@ -632,9 +674,33 @@ void BinderTester::case1200()
                       .TySpec.deriv(TypeKind::Pointer, CVR::Const)));
 }
 
-void BinderTester::case1201() { }
-void BinderTester::case1202() { }
-void BinderTester::case1203() { }
+void BinderTester::case1201()
+{
+    bind("int const * restrict x ;",
+         Expectation()
+             .binding(DeclSummary().Value("x", ValueKind::Variable)
+                      .TySpec.basis("int", NamedTypeKind::Builtin, BuiltinTypeKind::Int, CVR::Const)
+                      .TySpec.deriv(TypeKind::Pointer, CVR::Restrict)));
+}
+
+void BinderTester::case1202()
+{
+    bind("const int * restrict x ;",
+         Expectation()
+             .binding(DeclSummary().Value("x", ValueKind::Variable)
+                      .TySpec.basis("int", NamedTypeKind::Builtin, BuiltinTypeKind::Int, CVR::Const)
+                      .TySpec.deriv(TypeKind::Pointer, CVR::Restrict)));
+}
+
+void BinderTester::case1203()
+{
+    bind("const int * const restrict x ;",
+         Expectation()
+             .binding(DeclSummary().Value("x", ValueKind::Variable)
+                      .TySpec.basis("int", NamedTypeKind::Builtin, BuiltinTypeKind::Int, CVR::Const)
+                      .TySpec.deriv(TypeKind::Pointer, CVR::ConstAndRestrict)));
+}
+
 void BinderTester::case1204() { }
 void BinderTester::case1205() { }
 void BinderTester::case1206() { }
@@ -700,8 +766,24 @@ void BinderTester::case1251()
                       .TySpec.deriv(TypeKind::Pointer, CVR::Const)));
 }
 
-void BinderTester::case1252() { }
-void BinderTester::case1253() { }
+void BinderTester::case1252()
+{
+    bind("int * restrict x ;",
+         Expectation()
+             .binding(DeclSummary().Value("x", ValueKind::Variable)
+                      .TySpec.basis("int", NamedTypeKind::Builtin, BuiltinTypeKind::Int, CVR::None)
+                      .TySpec.deriv(TypeKind::Pointer, CVR::Restrict)));
+}
+
+void BinderTester::case1253()
+{
+    bind("x * restrict y ;",
+         Expectation()
+             .binding(DeclSummary().Value("y", ValueKind::Variable)
+                      .TySpec.basis("x", NamedTypeKind::Synonym, BuiltinTypeKind::UNSPECIFIED, CVR::None)
+                      .TySpec.deriv(TypeKind::Pointer, CVR::Restrict)));
+}
+
 void BinderTester::case1254() { }
 void BinderTester::case1255() { }
 void BinderTester::case1256() { }

diff --git a/C/tests/TestExpectation.h b/C/tests/TestExpectation.h
@@ -49,6 +49,8 @@ enum class CVR
     Volatile,
     Restrict,
     ConstAndVolatile,
+    ConstAndRestrict,
+    Atomic,
     None
 };
 

diff --git a/C/tests/TestSuite_Internals.cpp b/C/tests/TestSuite_Internals.cpp
@@ -419,6 +419,21 @@ bool CVRMatches(const TypeSymbol* tySym, CVR cvr)
             }
             break;
 
+        case CVR::ConstAndRestrict:
+            if (!(tySym->isConstQualified())
+                    || !(tySym->isRestrictQualified())) {
+                DETAIL_MISMATCH("missing const restrict");
+                return false;
+            }
+            break;
+
+        case CVR::Atomic:
+            if (!tySym->isAtomicQualified()) {
+                DETAIL_MISMATCH("missing _Atomic");
+                return false;
+            }
+            break;
+
         case CVR::None:
             if (tySym->isConstQualified()) {
                 DETAIL_MISMATCH("spurious const");