Fix for issue #373

clang/include/clang/3C/ConstraintVariables.h

@@ -391,6 +391,8 @@ class PointerVariableConstraint : public ConstraintVariable {
     return S->getKind() == PointerVariable;
   }
 
+  std::string gatherQualStrings(void) const;
+
   std::string mkString(const EnvironmentMap &E, bool EmitName = true,
                        bool ForItype = false,
                        bool EmitPointee = false,

clang/include/clang/3C/ProgramInfo.h

@@ -114,11 +114,12 @@ class ProgramInfo : public ProgramVariableAdder {
   void unifyIfTypedef(const clang::Type*, clang::ASTContext&,
                       clang::DeclaratorDecl*, PVConstraint*);
 
-  std::pair<CVarSet, bool> lookupTypedef(PersistentSourceLoc PSL);
+  CVarOption lookupTypedef(PersistentSourceLoc PSL);
 
   bool seenTypedef(PersistentSourceLoc PSL);
 
-  void addTypedef(PersistentSourceLoc PSL, bool ShouldCheck);
+  void addTypedef(PersistentSourceLoc PSL, bool ShouldCheck, TypedefDecl *TD,
+                  ASTContext& C);
 
 private:
   // List of constraint variables for declarations, indexed by their location in
@@ -132,7 +133,7 @@ class ProgramInfo : public ProgramVariableAdder {
   // The bool informs the rewriter whether or not this typedef should be
   // rewritten. It will be false for typedefs we don't support rewritting,
   // such as typedefs that are pointers to anonymous structs
-  std::map<PersistentSourceLoc, std::pair<CVarSet, bool>> typedefVars;
+  std::map<PersistentSourceLoc, CVarOption> typedefVars;
 
   // Map with the same purpose as the Variables map, this stores constraint
   // variables for non-declaration expressions.

clang/lib/3C/ConstraintBuilder.cpp

@@ -502,7 +502,8 @@ class ConstraintGenVisitor : public RecursiveASTVisitor<ConstraintGenVisitor> {
       if (!Info.seenTypedef(PSL))
         // Add this typedef to the program info, if it contains a ptr to
         // an anonymous struct we mark as not being rewritable
-        Info.addTypedef(PSL, !PtrToStructDef::containsPtrToStructDef(TD));
+        Info.addTypedef(PSL, !PtrToStructDef::containsPtrToStructDef(TD),
+                        TD, *Context);
 
       return true;
   }

clang/lib/3C/ConstraintVariables.cpp

@@ -580,6 +580,7 @@ void PointerVariableConstraint::getQualString(uint32_t TypeIdx,
 
 void PointerVariableConstraint::insertQualType(uint32_t TypeIdx,
                                                QualType &QTy) {
+  if (QTy.isConstQualified())
   if (QTy.isConstQualified())
     QualMap[TypeIdx].insert(ConstQualification);
   if (QTy.isVolatileQualified())
@@ -653,11 +654,23 @@ void PointerVariableConstraint::setTypedef(TypedefNameDecl* T, std::string s) {
 // variables and potentially nested function pointer declaration. Produces a
 // string that can be replaced in the source code.
 
+std::string PointerVariableConstraint::gatherQualStrings(void) const {
+  std::ostringstream S;
+  uint32_t Idx = 0;
+
+  for (auto It = Vars.begin(); It != Vars.end(); It++, Idx++) {
+    getQualString(Idx, S);
+  }
+
+  return S.str();
+}
+
 std::string PointerVariableConstraint::mkString(const EnvironmentMap &E,
                                                 bool EmitName, bool ForItype,
                                                 bool EmitPointee, bool UnmaskTypedef) const {
   if (IsTypedef && !UnmaskTypedef) {
-    return typedefString + (EmitName && getName() != RETVAR ? (" " + getName()) : " ");
+    return gatherQualStrings() + typedefString +
+           (EmitName && getName() != RETVAR ? (" " + getName()) : " ");
   }
 
   std::ostringstream Ss;
@@ -809,14 +822,16 @@ std::string PointerVariableConstraint::mkString(const EnvironmentMap &E,
     EndStrs.push_front(" " + getName());
   }
 
-  if (EmittedBase == false) {
+  if (!EmittedBase) {
     // If we have a FV pointer, then our "base" type is a function pointer.
     // type.
     if (FV) {
       Ss << FV->mkString(E);
     } else if (typedeflevelinfo.hasTypedef) {
-      auto name = typedeflevelinfo.typedefName;
-      Ss << name;
+      std::ostringstream Buf;
+      getQualString(typedeflevelinfo.typedefLevel, Buf);
+      auto Name = typedeflevelinfo.typedefName;
+      Ss << Buf.str() << Name;
     } else {
       Ss << BaseType;
     }

clang/lib/3C/DeclRewriter.cpp

@@ -54,17 +54,19 @@ void DeclRewriter::rewriteDecls(ASTContext &Context, ProgramInfo &Info,
     if (const auto &TD  = dyn_cast<TypedefDecl>(D)) {
       auto PSL = PersistentSourceLoc::mkPSL(TD, Context);
       if (!TD->getUnderlyingType()->isBuiltinType()) { // Don't rewrite base types like int
-        const auto pair = Info.lookupTypedef(PSL);
-        const auto VSet = pair.first;
-        if (!VSet.empty()) { // We ignore typedefs that are never used
-          const auto Var = VSet.begin();
+        const auto O = Info.lookupTypedef(PSL);
+        if (O.hasValue()) {
+          const auto &Var = O.getValue();
           const auto &Env = Info.getConstraints().getVariables();
-          if ((*Var)->anyChanges(Env)) {
-            std::string newTy = getStorageQualifierString(D) +
-              (*Var)->mkString(Info.getConstraints().getVariables(),
-                               false, false, false, true) + " " + TD->getNameAsString();
-            RewriteThese.insert(new TypedefDeclReplacement(TD, nullptr, newTy));
-          }
+          if (Var.anyChanges(Env)) {
+            std::string newTy =
+                  getStorageQualifierString(D) +
+                  Var.mkString(Info.getConstraints().getVariables(), false,
+                                   false, false, true) +
+                  " " + TD->getNameAsString();
+              RewriteThese.insert(
+                  new TypedefDeclReplacement(TD, nullptr, newTy));
+            }
         }
       }
     }

clang/lib/3C/ProgramInfo.cpp

@@ -642,16 +642,16 @@ void ProgramInfo::addVariable(clang::DeclaratorDecl *D,
 }
 
 void ProgramInfo::unifyIfTypedef(const Type* Ty, ASTContext& Context, DeclaratorDecl* Decl, PVConstraint* P) {
-  if (const auto TDT = dyn_cast<TypedefType>(Ty)) {
-    auto Decl = TDT->getDecl();
-    auto PSL = PersistentSourceLoc::mkPSL(Decl, Context);
-    auto &pair = typedefVars[PSL];
-    CVarSet& bounds = pair.first;
-    if (pair.second) {
-      P->setTypedef(Decl, Decl->getNameAsString());
-      constrainConsVarGeq(P, bounds, CS, &PSL, Same_to_Same, true, this);
-      bounds.insert(P);
+  if (const auto* TDT = dyn_cast<TypedefType>(Ty)) {
+    auto* TDecl = TDT->getDecl();
+    auto PSL = PersistentSourceLoc::mkPSL(TDecl, Context);
+    auto O = lookupTypedef(PSL);
+    if (O.hasValue()) {
+      ConstraintVariable& Bounds = O.getValue();
+      P->setTypedef(TDecl, TDecl->getNameAsString());
+      constrainConsVarGeq(P, &Bounds, CS, &PSL, Same_to_Same, true, this);
     }
+
   }
 }
 
@@ -1034,15 +1034,21 @@ ProgramInfo::getTypeParamBindings(CallExpr *CE, ASTContext *C) const {
   return TypeParamBindings.at(PSL);
 }
 
-std::pair<CVarSet, bool> ProgramInfo::lookupTypedef(PersistentSourceLoc PSL) {
+CVarOption ProgramInfo::lookupTypedef(PersistentSourceLoc PSL) {
   return typedefVars[PSL];
 }
 
 bool ProgramInfo::seenTypedef(PersistentSourceLoc PSL) {
   return typedefVars.count(PSL) != 0;
 }
 
-void ProgramInfo::addTypedef(PersistentSourceLoc PSL, bool ShouldCheck) {
-  CVarSet empty;
-  typedefVars[PSL] = make_pair(empty, ShouldCheck);
+void ProgramInfo::addTypedef(PersistentSourceLoc PSL, bool ShouldCheck,
+                             TypedefDecl* TD, ASTContext &C) {
+  auto Name = "typedef__" + TD->getNameAsString();
+  auto* PV = new PointerVariableConstraint(TD->getUnderlyingType(), nullptr,
+                                       Name, *this, C);
+  if (ShouldCheck && canWrite(PSL.getFileName()))
+    this->typedefVars[PSL] = {*PV};
+   else
+    this->typedefVars[PSL] = {};
 }

clang/test/3C/definedType.c

@@ -2,7 +2,7 @@
 // RUN: 3c -addcr %s -- | FileCheck -match-full-lines -check-prefixes="CHECK_NOALL","CHECK" %s
 // RUN: 3c -addcr %s -- | %clang -c -fcheckedc-extension -x c -o /dev/null -
 // RUN: 3c -alltypes -output-postfix=checked %s
-// RUN: 3c -alltypes %S/definedType.checked.c | diff %S/definedType.checked.c -
+// RUN: 3c -alltypes %S/definedType.checked.c | count 0
 // RUN: rm %S/definedType.checked.c
 
 #include <stddef.h>

clang/test/3C/typedefs.c

@@ -32,6 +32,8 @@ intptr bar(intptr x) {
 	return x;
 }
 
+typedef int* integer;
+//CHECK: typedef _Ptr<int> integer;
 int foo(void) { 
     //CHECK: int foo(void) {
     int x = 3;
@@ -44,6 +46,14 @@ int foo(void) {
     bad b = (int*) 3;
     //CHECK: bad b = (int*) 3;
     badP b2 = (intptr*) 3;
+    typedef int nat;
+    const nat z = 3;
+    const nat* cnstp = &z;
+    //CHECK: _Ptr<const nat> cnstp = &z;
+    int w = 34;
+    const integer c = &w;
+    //CHECK: const integer c = &w;
+
 
     return *p;
 }