Initial enhancement to allow 3C to infer generics (checkedc#683)

Enhancement for functions with single `void*` parameter or return to be converted into `_For_any` generics.

Author: kyleheadley

clang/include/clang/3C/ConstraintResolver.h

@@ -42,6 +42,8 @@ class ConstraintResolver {
 
   CVarSet getCalleeConstraintVars(CallExpr *CE);
 
+  bool isCastofGeneric(CastExpr *C);
+
   // Handle assignment of RHS expression to LHS expression using the
   // given action.
   void constrainLocalAssign(Stmt *TSt, Expr *LHS, Expr *RHS,

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

@@ -354,7 +354,9 @@ class PointerVariableConstraint : public ConstraintVariable {
   // Generic types can be used with fewer restrictions, so this field is used
   // stop assignments with generic variables from forcing constraint variables
   // to be wild.
-  int GenericIndex;
+  // Source is generated from the source code, Inferred is set internally
+  int SourceGenericIndex;
+  int InferredGenericIndex;
 
   // Empty array pointers are represented the same as standard pointers. This
   // lets pointers be passed to functions expecting a zero width array. This
@@ -378,7 +380,8 @@ class PointerVariableConstraint : public ConstraintVariable {
   PointerVariableConstraint(std::string Name) :
     ConstraintVariable(PointerVariable, "", Name), FV(nullptr),
     SrcHasItype(false), PartOfFuncPrototype(false), Parent(nullptr),
-    GenericIndex(-1), IsZeroWidthArray(false), IsTypedef(false), TDT(nullptr),
+    SourceGenericIndex(-1), InferredGenericIndex(-1),
+    IsZeroWidthArray(false), IsTypedef(false), TDT(nullptr),
     TypedefLevelInfo({}), IsVoidPtr(false) {}
 
 public:
@@ -404,9 +407,12 @@ class PointerVariableConstraint : public ConstraintVariable {
   // Get bounds annotation.
   std::string getBoundsStr() const { return BoundsAnnotationStr; }
 
-  bool getIsGeneric() const { return GenericIndex >= 0; }
-  int getGenericIndex() const { return GenericIndex; }
-
+  bool isGeneric() const { return InferredGenericIndex >= 0; }
+  int getGenericIndex() const { return InferredGenericIndex; }
+  void setGenericIndex(int idx) { InferredGenericIndex = idx; }
+  bool isGenericChanged() const {
+    return SourceGenericIndex != InferredGenericIndex;
+  }
   // Was this variable a checked pointer in the input program?
   // This is important for two reasons: (1) externs that are checked should be
   // kept that way during solving, (2) nothing that was originally checked
@@ -449,6 +455,10 @@ class PointerVariableConstraint : public ConstraintVariable {
   // ForceGenericIndex: CheckedC supports generic types (_Itype_for_any) which
   //                    need less restrictive constraints. Set >= 0 to indicate
   //                    that this variable should be considered generic.
+  // PotentialGeneric: Whether this may become generic after analysis. Disables
+  //                   constraint to wild for non-generics. If you use this
+  //                   you'll have to add that constraint later if it is
+  //                   not generic.
   // TSI: TypeSourceInfo object gives access to information about the source
   //      code representation of the type. Allows for more precise rewriting by
   //      preserving the exact syntax used to write types that aren't rewritten
@@ -458,6 +468,7 @@ class PointerVariableConstraint : public ConstraintVariable {
                             const clang::ASTContext &C,
                             std::string *InFunc = nullptr,
                             int ForceGenericIndex = -1,
+                            bool PotentialGeneric = false,
                             bool VarAtomForChecked = false,
                             TypeSourceInfo *TSI = nullptr,
                             const clang::QualType &ItypeT = QualType());
@@ -550,7 +561,7 @@ class FVComponentVariable {
   FVComponentVariable(const clang::QualType &QT, const clang::QualType &ITypeT,
                       clang::DeclaratorDecl *D, std::string N, ProgramInfo &I,
                       const clang::ASTContext &C, std::string *InFunc,
-                      bool HasItype);
+                      bool PotentialGeneric, bool HasItype);
 
   void mergeDeclaration(FVComponentVariable *From, ProgramInfo &I,
                         std::string &ReasonFailed);
@@ -567,6 +578,11 @@ class FVComponentVariable {
   PVConstraint *getInternal() const { return InternalConstraint; }
   PVConstraint *getExternal() const { return ExternalConstraint; }
 
+  void setGenericIndex(int idx) {
+    ExternalConstraint->setGenericIndex(idx);
+    InternalConstraint->setGenericIndex(idx);
+  }
+
   void equateWithItype(ProgramInfo &CS, const std::string &ReasonUnchangeable,
                        PersistentSourceLoc *PSL) const;
 
@@ -595,7 +611,7 @@ class FunctionVariableConstraint : public ConstraintVariable {
   // Flag to indicate whether this is a function pointer or not.
   bool IsFunctionPtr;
 
-  // Count of type parameters from `_Itype_for_any(...)`.
+  // Count of type parameters (originally from `_Itype_for_any(...)`).
   int TypeParams;
 
   void equateFVConstraintVars(ConstraintVariable *CV, ProgramInfo &Info) const;
@@ -652,9 +668,24 @@ class FunctionVariableConstraint : public ConstraintVariable {
   bool srcHasItype() const override;
   bool srcHasBounds() const override;
 
+  // The number of type variables
+  int getGenericParams() const {
+    return TypeParams;
+  }
+  // remove added generics
+  // use when we constrain a potential generic param to wild
+  void resetGenericParams() {
+    TypeParams = 0;
+  }
+
+  // The type parameter index of the return
   int getGenericIndex() const {
     return ReturnVar.ExternalConstraint->getGenericIndex();
   }
+  // Change the type parameter index of the return
+  void setGenericIndex(int idx) {
+    ReturnVar.ExternalConstraint->setGenericIndex(idx);
+  }
 
   bool solutionEqualTo(Constraints &CS, const ConstraintVariable *CV,
                        bool ComparePtyp = true) const override;

clang/include/clang/3C/Constraints.h

@@ -32,6 +32,7 @@ class ConstraintsGraph;
 
 #define DEFAULT_REASON "UNKNOWN_REASON"
 #define POINTER_IS_ARRAY_REASON "Pointer is array but alltypes is disabled."
+#define VOID_TYPE_REASON "Default void* type"
 #define UNWRITABLE_REASON "Source code in non-writable file."
 
 template <typename T> struct PComp {

clang/include/clang/3C/DeclRewriter.h

@@ -102,9 +102,10 @@ class FunctionDeclBuilder : public RecursiveASTVisitor<FunctionDeclBuilder> {
   // Get existing itype string from constraint variables.
   std::string getExistingIType(ConstraintVariable *DeclC);
 
-  virtual void buildDeclVar(const FVComponentVariable *CV, DeclaratorDecl *Decl,
-                            std::string &Type, std::string &IType,
-                            std::string UseName, bool &RewriteParm,
+  virtual void buildDeclVar(const FVComponentVariable *CV,
+                            DeclaratorDecl *Decl, std::string &Type,
+                            std::string &IType, std::string UseName,
+                            bool &RewriteGen, bool &RewriteParm,
                             bool &RewriteRet, bool StaticFunc);
   void buildCheckedDecl(PVConstraint *Defn, DeclaratorDecl *Decl,
                         std::string &Type, std::string &IType,

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

@@ -43,9 +43,40 @@ class ProgramVariableAdder {
 
 typedef std::pair<CVarSet, BKeySet> CSetBkeyPair;
 
+// The pair of CVs are the type param constraint and an optional
+// constraint used to get the generic index. A better solution would have
+// generic constraints saved within ConstraintVariables, but those don't
+// exist at this time.
+struct TypeParamConstraint {
+  ConstraintVariable *MainConstraint;
+  ConstraintVariable *GenericAddition;
+  TypeParamConstraint() :
+      MainConstraint(nullptr), GenericAddition(nullptr) {}
+  TypeParamConstraint(ConstraintVariable *M, ConstraintVariable *G) :
+      MainConstraint(M), GenericAddition(G) {}
+  // Fast. Whether `getConstraint` will return something other than nullptr.
+  bool isConsistent() const { return MainConstraint != nullptr; }
+  // Provides generic information if available and safe. This is somewhat of
+  // a hack for nested generics and returns (the constraint for) a local
+  // parameter. Otherwise, returns the generated constraint, which can also be
+  // accessed as `MainConstraint`.
+  ConstraintVariable *getConstraint(const EnvironmentMap &E) {
+    if (MainConstraint != nullptr && GenericAddition != nullptr &&
+        GenericAddition->isSolutionChecked(E)) {
+      return GenericAddition;
+    } else {
+      return MainConstraint;
+    }
+  }
+};
+
 class ProgramInfo : public ProgramVariableAdder {
 public:
-  typedef std::map<unsigned int, ConstraintVariable *> CallTypeParamBindingsT;
+
+  // This map holds similar information as the type variable map in
+  // ConstraintBuilder.cpp, but it is stored in a form that is usable during
+  // rewriting.
+  typedef std::map<unsigned int, TypeParamConstraint> CallTypeParamBindingsT;
 
   typedef std::map<std::string, FVConstraint *> ExternalFunctionMapType;
   typedef std::map<std::string, ExternalFunctionMapType> StaticFunctionMapType;
@@ -119,7 +150,8 @@ class ProgramInfo : public ProgramVariableAdder {
   }
 
   void setTypeParamBinding(CallExpr *CE, unsigned int TypeVarIdx,
-                           ConstraintVariable *CV, ASTContext *C);
+                           ConstraintVariable *CV,
+                           ConstraintVariable* Ident, ASTContext *C);
   bool hasTypeParamBindings(CallExpr *CE, ASTContext *C) const;
   const CallTypeParamBindingsT &getTypeParamBindings(CallExpr *CE,
                                                      ASTContext *C) const;
@@ -217,11 +249,6 @@ class ProgramInfo : public ProgramVariableAdder {
   // used as keys for maps from ASTNodes.
   std::map<ASTContext *, unsigned int> TranslationUnitIdxMap;
 
-  // Special-case handling for decl introductions. For the moment this covers:
-  //  * void-typed variables
-  //  * va_list-typed variables
-  void specialCaseVarIntros(ValueDecl *D, ASTContext *Context);
-
   // Inserts the given FVConstraint set into the extern or static function map.
   // Returns the merged version if it was a redeclaration, or the constraint
   // parameter if it was new.

clang/include/clang/3C/RewriteUtils.h

@@ -84,21 +84,23 @@ class FunctionDeclReplacement
                                   DeclReplacement::DRK_FunctionDecl> {
 public:
   explicit FunctionDeclReplacement(FunctionDecl *D, std::string R, bool Return,
-                                   bool Params)
-      : DeclReplacementTempl(D, nullptr, R), RewriteReturn(Return),
-        RewriteParams(Params) {
+                                   bool Params, bool Generic = false)
+      : DeclReplacementTempl(D, nullptr, R), RewriteGeneric(Generic),
+        RewriteReturn(Return), RewriteParams(Params) {
     assert("Doesn't make sense to rewrite nothing!" &&
-           (RewriteReturn || RewriteParams));
+           (RewriteGeneric || RewriteReturn || RewriteParams));
   }
 
   SourceRange getSourceRange(SourceManager &SM) const override;
 
 private:
   // This determines if the full declaration or the return will be replaced.
+  bool RewriteGeneric;
   bool RewriteReturn;
   bool RewriteParams;
 
   SourceLocation getDeclBegin(SourceManager &SM) const;
+  SourceLocation getReturnBegin(SourceManager &SM) const;
   SourceLocation getParamBegin(SourceManager &SM) const;
   SourceLocation getReturnEnd(SourceManager &SM) const;
   SourceLocation getDeclEnd(SourceManager &SM) const;

clang/include/clang/3C/TypeVariableAnalysis.h

@@ -20,8 +20,9 @@ class TypeVariableEntry {
 public:
   // Note: does not initialize TyVarType!
   TypeVariableEntry() : IsConsistent(false), TypeParamConsVar(nullptr) {}
-  TypeVariableEntry(QualType Ty, std::set<ConstraintVariable *> &CVs,
-                    bool ForceInconsistent = false)
+  TypeVariableEntry(QualType Ty, std::set<ConstraintVariable *> &CVs
+                    , bool ForceInconsistent = false
+                    , ConstraintVariable *IdentCV = nullptr)
       : TypeParamConsVar(nullptr) {
     // We'll need a name to provide the type arguments during rewriting, so no
     // anonymous types are allowed.
@@ -30,6 +31,7 @@ class TypeVariableEntry {
                    !isTypeAnonymous(Ty->getPointeeOrArrayElementType());
     TyVarType = Ty;
     ArgConsVars = CVs;
+    GenArgumentCV = IdentCV;
   }
 
   bool getIsConsistent() const;
@@ -38,10 +40,12 @@ class TypeVariableEntry {
   // Note: undefined behaviour if `getIsConsistent` is false
   std::set<ConstraintVariable *> &getConstraintVariables();
   ConstraintVariable *getTypeParamConsVar();
+  ConstraintVariable *getGenArgCV();
 
   void insertConstraintVariables(std::set<ConstraintVariable *> &CVs);
   void setTypeParamConsVar(ConstraintVariable *CV);
-  void updateEntry(QualType Ty, std::set<ConstraintVariable *> &CVs);
+  void updateEntry(QualType Ty, std::set<ConstraintVariable *> &CVs,
+                   ConstraintVariable *IdentCV);
 
 private:
   // Is this type variable instantiated consistently. True when all uses have
@@ -61,6 +65,12 @@ class TypeVariableEntry {
   // A single constraint variable for solving the checked type of the type
   // variable. It is constrained GEQ all elements of ArgConsVars.
   ConstraintVariable *TypeParamConsVar;
+
+  // If an argument is a single identifier, store the constraint variable
+  // to recognize changes in type from inferred generics. Null otherwise.
+  // Meaningless if `TypeParamConsVar` has a basetype other than void, and
+  // when we have generic index constraints, those should be favored over this
+  ConstraintVariable *GenArgumentCV;
 };
 
 // Stores the instantiated type for each type variables. This map has
@@ -100,7 +110,8 @@ class TypeVarVisitor : public RecursiveASTVisitor<TypeVarVisitor>,
   ConstraintResolver CR;
   TypeVariableMapT TVMap;
 
-  void insertBinding(CallExpr *CE, const int TyIdx, QualType Ty, CVarSet &CVs);
+  void insertBinding(CallExpr *CE, const int TyIdx, QualType Ty,
+                     CVarSet &CVs, ConstraintVariable *IdentCV = nullptr);
 };
 
 bool typeArgsProvided(CallExpr *Call);

clang/lib/3C/CastPlacement.cpp

@@ -57,9 +57,11 @@ bool CastPlacementVisitor::VisitCallExpr(CallExpr *CE) {
       Expr *ArgExpr = A;
       if (FD && PIdx < FD->getNumParams()) {
         const int TyVarIdx = FV->getExternalParam(PIdx)->getGenericIndex();
-        if (TypeVars.find(TyVarIdx) != TypeVars.end() &&
-            TypeVars[TyVarIdx] != nullptr)
-          TypeVar = TypeVars[TyVarIdx];
+        // Check if local type vars are available
+        if (TypeVars.find(TyVarIdx) != TypeVars.end()) {
+          TypeVar = TypeVars[TyVarIdx].getConstraint(
+                  Info.getConstraints().getVariables());
+        }
       }
       if (TypeVar != nullptr)
         ArgExpr = ArgExpr->IgnoreImpCasts();

clang/lib/3C/CheckedRegions.cpp

@@ -230,7 +230,7 @@ bool CheckedRegionFinder::VisitCallExpr(CallExpr *C) {
     if (FD) {
       if (Info.hasTypeParamBindings(C, Context))
         for (auto Entry : Info.getTypeParamBindings(C, Context))
-          Wild |= (Entry.second == nullptr);
+          Wild |= !Entry.second.isConsistent();
       auto Type = FD->getReturnType();
       Wild |= (!(FD->hasPrototype() || FD->doesThisDeclarationHaveABody())) ||
               containsUncheckedPtr(Type);

clang/lib/3C/ConstraintBuilder.cpp

@@ -166,7 +166,8 @@ class FunctionVisitor : public RecursiveASTVisitor<FunctionVisitor> {
     // Is cast compatible with LHS type?
     QualType SrcT = C->getSubExpr()->getType();
     QualType DstT = C->getType();
-    if (!isCastSafe(DstT, SrcT) && !Info.hasPersistentConstraints(C, Context)) {
+    if (!CB.isCastofGeneric(C) && !isCastSafe(DstT, SrcT)
+      && !Info.hasPersistentConstraints(C, Context)) {
       auto CVs = CB.getExprConstraintVarsSet(C->getSubExpr());
       std::string Rsn =
           "Cast from " + SrcT.getAsString() + " to " + DstT.getAsString();