Add support for polymorphic bounds safe interface functions (#546)

1. Parsing code to identify our new checked c keyword "_Itype_for_any" is added.
2. Design document md file added for _Itype_for_any implementation details
3. Parser now treats void * and pointer to TypeVariableType as equivalent types when the TypeVariableType is encountered under the _Itype_for_any scope.
4. "_Itype_for_any" are now compatible with declarations of non bounds safe generic function allowing redeclaration of interface funcions with _Itype_for_any specifier and type variables.
5. Parsing of calls to itype generic functions from checked scope now expects types to be provided.
6. This is optional for calls from unchecked scope.

Author: Prabhuk

docs/checkedc/2018-07-27-BoundsSafeInterfaces.md

@@ -0,0 +1,24 @@
+**Function Specifier for Bounds Safe Interfaces:**
+
+*itype_for_any(<COMMA_SEPARATED_TYPE_VARIABLES>)*
+
+* Creates a new scope
+* Restrictions on parameters:
+    * No type variable can be used as the type of function parameters
+    * Type variables of parameters must be contained within itype clauses
+        * e.g. 
+            `itype_for_any(T)
+                void* foo(void* arg1 : itype(_Ptr<T>));`
+* There are no restrictions on local variables
+    * i.e., Typevariables can be used as the type of local variables created within function body; even if the scope is unchecked. 
+* itype_for_any and for_any scopes cannot be nested
+* Design discussion with David MoM:
+    * The bounds interface function will have a polymorphic type associated with it
+    * If the caller doesn't apply a type, then the default type of the parameters will be applied as types
+    * e.g
+        * For the foo function shown above, the caller `foo<int>(x)` will force arg1 to be a pointer to int
+        * But the caller `foo(y)` will treat arg1 as pointer to void type
+        * This design is to enable foo to be called from unchecked scopes to allow incremental adoption
+        
+
+      

include/clang/AST/ASTContext.h

@@ -1198,10 +1198,12 @@ class ASTContext : public RefCountedBase<ASTContext> {
   /// pointer to blocks.
   QualType getBlockDescriptorExtendedType() const;
 
-  /// Returns a type variable type based on the depth of the "for any" scope 
-  /// where type variable is declared, and the position of the type variable in
-  /// _For_any qualifier.
-  QualType getTypeVariableType(unsigned int depth, unsigned int position) const;
+  /// Returns a type variable type based on the depth of "for any" or
+  /// "itype for any" scope where type variable is declared, and the
+  /// position of the type variable in _For_any or _Itype_for_any
+  ///.qualifier respectively
+  QualType getTypeVariableType(unsigned int depth, unsigned int position,
+                               bool isBoundsInterfaceType) const;
 
   void setcudaConfigureCallDecl(FunctionDecl *FD) {
     cudaConfigureCallDecl = FD;
@@ -2486,12 +2488,16 @@ class ASTContext : public RefCountedBase<ASTContext> {
   /// at least as much checking as the other type T2.  Return true if it does
   /// or false if it does not or the types differ in some other way than
   /// checkedness.
+  /// Note:: In bounds safe interface scopes, this function
+  /// returns true if T1 is a TypeVariableType and T2 is a pointer to void type
   bool isAtLeastAsCheckedAs(QualType T1, QualType T2) const;
 
   /// \brief Determine whether a pointer, array, or function type T1
   /// is the same as the other pointer, array, or function type T2 if
   /// checkedness is ignored.  Return true if does or false if the types
   /// differ in some other way than checkedness.
+  /// Note:: In bounds safe interface scopes, this function
+  /// returns true if T1 is a TypeVariableType and T2 is a pointer to void type
   bool isEqualIgnoringChecked(QualType T1, QualType T2) const;
 
   /// \brief Return true if this type is a checked type that is not

include/clang/AST/Decl.h

@@ -1789,6 +1789,7 @@ class FunctionDecl : public DeclaratorDecl, public DeclContext,
   unsigned IsLateTemplateParsed : 1;
   unsigned IsConstexpr : 1;
   unsigned IsGenericFunction : 1;
+  unsigned IsItypeGenericFunction : 1; //Checked C - Function specifier _Itype_for_any
   // Indicates whether the function is declared with a _Checked or
   // _Unchecked specifier.
   unsigned CheckedSpecifier : 2;
@@ -1896,7 +1897,7 @@ class FunctionDecl : public DeclaratorDecl, public DeclContext,
         IsDeleted(false), IsTrivial(false), IsDefaulted(false),
         IsExplicitlyDefaulted(false), HasImplicitReturnZero(false),
         IsLateTemplateParsed(false), IsConstexpr(isConstexprSpecified),
-        IsGenericFunction(false),
+        IsGenericFunction(false), IsItypeGenericFunction(false),
         CheckedSpecifier(CheckedFunctionSpecifiers::CFS_None),
         InstantiationIsPending(false),
         UsesSEHTry(false), HasSkippedBody(false), WillHaveBody(false),
@@ -1964,6 +1965,9 @@ class FunctionDecl : public DeclaratorDecl, public DeclContext,
   void setGenericFunctionFlag(bool f) { IsGenericFunction = f; }
   bool isGenericFunction() const { return IsGenericFunction; }
 
+  void setItypeGenericFunctionFlag(bool f) { IsItypeGenericFunction = f; }
+  bool isItypeGenericFunction() const { return IsItypeGenericFunction; }
+
   void setCheckedSpecifier(CheckedFunctionSpecifiers CS) { CheckedSpecifier = CS; }
   CheckedFunctionSpecifiers getCheckedSpecifier() {
     return (CheckedFunctionSpecifiers) CheckedSpecifier;

include/clang/AST/Type.h

@@ -3429,12 +3429,14 @@ class FunctionProtoType : public FunctionType, public llvm::FoldingSetNode {
   /// Extra information about a function prototype.
   struct ExtProtoInfo {
     ExtProtoInfo()
-        : Variadic(false), HasTrailingReturn(false), numTypeVars(0), 
+        : Variadic(false), HasTrailingReturn(false), numTypeVars(0),
+          GenericFunction(false), ItypeGenericFunction(false),
           TypeQuals(0), RefQualifier(RQ_None), ExtParameterInfos(nullptr),
           ParamAnnots(nullptr), ReturnAnnots() {}
 
     ExtProtoInfo(CallingConv CC)
-        : ExtInfo(CC), Variadic(false), HasTrailingReturn(false), numTypeVars(0), 
+        : ExtInfo(CC), Variadic(false), HasTrailingReturn(false), numTypeVars(0),
+          GenericFunction(false), ItypeGenericFunction(false),
           TypeQuals(0), RefQualifier(RQ_None), ExtParameterInfos(nullptr),
           ParamAnnots(nullptr), ReturnAnnots() {}
 
@@ -3448,6 +3450,8 @@ class FunctionProtoType : public FunctionType, public llvm::FoldingSetNode {
     bool Variadic : 1;
     bool HasTrailingReturn : 1;
     unsigned numTypeVars : 15;
+    bool GenericFunction : 1;
+    bool ItypeGenericFunction : 1;
     unsigned char TypeQuals;
     RefQualifierKind RefQualifier;
     ExceptionSpecInfo ExceptionSpec;
@@ -3487,6 +3491,9 @@ class FunctionProtoType : public FunctionType, public llvm::FoldingSetNode {
   /// Whether the function is variadic.
   unsigned Variadic : 1;
 
+  bool GenericFunction : 1;
+  bool ItypeGenericFunction : 1;
+
   /// Whether this function has a trailing return type.
   unsigned HasTrailingReturn : 1;
 
@@ -3553,6 +3560,9 @@ class FunctionProtoType : public FunctionType, public llvm::FoldingSetNode {
     return param_type_begin()[i];
   }
   unsigned getNumTypeVars() const { return NumTypeVars; }
+  bool isGenericFunction() const { return GenericFunction; }
+  bool isItypeGenericFunction() const { return ItypeGenericFunction; }
+
   ArrayRef<QualType> getParamTypes() const {
     return llvm::makeArrayRef(param_type_begin(), param_type_end());
   }
@@ -3588,6 +3598,8 @@ class FunctionProtoType : public FunctionType, public llvm::FoldingSetNode {
     EPI.ParamAnnots = hasParamAnnots() ? param_annots_begin() : nullptr;
     EPI.ReturnAnnots = getReturnAnnots();
     EPI.numTypeVars = getNumTypeVars();
+    EPI.GenericFunction = isGenericFunction();
+    EPI.ItypeGenericFunction = isItypeGenericFunction();
     return EPI;
   }
 
@@ -3835,10 +3847,11 @@ class TypeVariableType : public Type, public llvm::FoldingSetNode {
   // prototype scope depth, this keeps track of the depth of forany scope.
   unsigned int depth;
   unsigned int index;
+  bool isBoundsInterfaceType;
 protected:
-  TypeVariableType(unsigned int inDepth, unsigned int inIndex)
+  TypeVariableType(unsigned int inDepth, unsigned int inIndex, bool inBoundsInterface)
     : Type(TypeVariable, QualType(), false, false, false, false),
-    depth(inDepth), index(inIndex) { }
+    depth(inDepth), index(inIndex), isBoundsInterfaceType(inBoundsInterface) { }
   friend class ASTContext;
 public:
   bool isSugared(void) const { return false; }
@@ -3847,6 +3860,12 @@ class TypeVariableType : public Type, public llvm::FoldingSetNode {
   void SetDepth(unsigned int i) { depth = i; }
   unsigned int GetIndex(void) const { return index; }
   void SetIndex(unsigned int i) { index = i; }
+  void SetInBoundsInterface (bool isInBoundsInterface) {
+    isBoundsInterfaceType = isInBoundsInterface;
+  }
+  bool IsBoundsInterfaceType () const {
+    return isBoundsInterfaceType;
+  }
 
   void Profile(llvm::FoldingSetNodeID &ID) {
     Profile(ID, depth, index);

include/clang/Basic/DiagnosticParseKinds.td

@@ -1201,10 +1201,10 @@ def err_forany_type_variable_declaration_expected : Error<
 def err_forany_type_variable_identifier_expected : Error<
   "expected type variable identifier">;
 
-def err_forany_unexpected_token : Error<
-  "unexpected token in _For_any specifier">;
+def err_generic_specifier_unexpected_token : Error<
+  "unexpected token in %0 specifier">;
 
-def err_forany_comma_or_parenthesis_expected : Error<
+def err_generic_specifier_comma_or_parenthesis_expected : Error<
   "expected , or )">;
 
 def err_expected_list_of_types_expr_for_generic_function : Error<

include/clang/Basic/DiagnosticSemaKinds.td

@@ -9516,7 +9516,7 @@ def err_bounds_type_annotation_lost_checking : Error<
    "bounds to have no prototype">;
 
  def note_previous_bounds_decl : Note<"previous %select{bounds|interop type}0 declaration is here">;
- 
+
   def err_decl_conflicting_annot : Error<
     "%select{function redeclaration has conflicting parameter %select{bounds|interop type}0|function "
     "redeclaration has conflicting return %select{bounds|interop type}0|variable redeclaration has "
@@ -9533,6 +9533,9 @@ def err_bounds_type_annotation_lost_checking : Error<
 
   def err_conflicting_annots : Error<"conflicting bounds annotations for %0">;
 
+  def err_decl_conflicting_function_specifiers : Error<
+    "conflicting function specifiers for %0. %1 and %2 are incompatible function specifiers.">;
+
   def err_out_of_scope_function_type_local : Error<
     "out-of-scope variable for bounds in a function type (a function type "
     "cannot reference local variables)">;

include/clang/Basic/TokenKinds.def

@@ -653,6 +653,7 @@ KEYWORD(_Unchecked                 , KEYCHECKEDC)
 KEYWORD(_Assume_bounds_cast        , KEYCHECKEDC)
 KEYWORD(_Dynamic_bounds_cast       , KEYCHECKEDC)
 KEYWORD(_For_any                   , KEYCHECKEDC)
+KEYWORD(_Itype_for_any             , KEYCHECKEDC)
 
 // Borland Extensions which should be disabled in strict conformance mode.
 ALIAS("_pascal"      , __pascal   , KEYBORLAND)

include/clang/Parse/Parser.h

@@ -1764,7 +1764,8 @@ class Parser : public CodeCompletionHandler {
   ExprResult ParseBoundsCastExpression();
 
   ExprResult ParseBoundsExpression();
-  bool ParseGenericFunctionExpression(ExprResult &Res);
+  bool ParseItypeAndGenericFunctionExpression(ExprResult &Res);
+
   QualType SubstituteTypeVariable(QualType QT,
     SmallVector<DeclRefExpr::GenericInstInfo::TypeArgument, 4> &typeNames);
 
@@ -2486,6 +2487,9 @@ class Parser : public CodeCompletionHandler {
   void ParseAtomicSpecifier(DeclSpec &DS);
   void ParseCheckedPointerSpecifiers(DeclSpec & DS);
   void ParseForanySpecifier(DeclSpec &DS);
+  bool ParseGenericFunctionSpecifierHelper(DeclSpec &DS,
+                                            Scope::ScopeFlags S);
+  void ParseItypeforanySpecifier(DeclSpec &DS);
 
   ExprResult ParseAlignArgument(SourceLocation Start,
                                 SourceLocation &EllipsisLoc);

include/clang/Sema/DeclSpec.h

@@ -366,6 +366,8 @@ class DeclSpec {
   unsigned FS_checked_specified : 2;
   // Checked C - For-any function specifier
   unsigned FS_forany_specified : 1;
+  // Checked C - _Itype_for_any function specifier
+  unsigned FS_itypeforany_specified : 1;
 
   // friend-specifier
   unsigned Friend_specified : 1;
@@ -387,6 +389,9 @@ class DeclSpec {
 
   TypedefDecl **TypeVarInfo;
   unsigned NumTypeVars : 15;
+  bool GenericFunction : 1;
+  bool ItypeGenericFunction : 1;
+
 
   // Scope specifier for the type spec, if applicable.
   CXXScopeSpec TypeScope;
@@ -409,7 +414,7 @@ class DeclSpec {
   SourceLocation FS_inlineLoc, FS_virtualLoc, FS_explicitLoc, FS_noreturnLoc;
   SourceLocation FS_forceinlineLoc;
   // Checked C - checked keyword location
-  SourceLocation FS_checkedLoc, FS_foranyLoc;
+  SourceLocation FS_checkedLoc, FS_foranyLoc, FS_itypeforanyloc;
   SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc, ConceptLoc;
   SourceLocation TQ_pipeLoc;
 
@@ -459,12 +464,15 @@ class DeclSpec {
       // Checked C - checked function
       FS_checked_specified(CFS_None),
       FS_forany_specified(false),
+      FS_itypeforany_specified(false),
       Friend_specified(false),
       Constexpr_specified(false),
       Concept_specified(false),
       Attrs(attrFactory),
       TypeVarInfo(nullptr),
       NumTypeVars(0),
+      GenericFunction(false),
+      ItypeGenericFunction(false),
       writtenBS(),
       ObjCQualifiers(nullptr) {
   }
@@ -605,11 +613,16 @@ class DeclSpec {
   SourceLocation getCheckedSpecLoc() const { return FS_checkedLoc; }
 
   bool isForanySpecified() const { return FS_forany_specified; }
+  bool isItypeforanySpecified() const { return FS_itypeforany_specified; }
   SourceLocation getForanySpecLoc() const { return FS_foranyLoc; }
 
   void setTypeVars(ASTContext &C, ArrayRef<TypedefDecl *> NewTypeVarInfo, unsigned NewNumTypeVars);
+  void setGenericFunction(bool IsGeneric) { GenericFunction = IsGeneric; }
+  void setItypeGenericFunction(bool IsItypeGeneric) { ItypeGenericFunction = IsItypeGeneric; }
   void setNumTypeVars(unsigned NewNumTypeVars) { NumTypeVars = NewNumTypeVars; }
   unsigned getNumTypeVars(void) const { return NumTypeVars; }
+  bool isGenericFunction(void) const { return GenericFunction; }
+  bool isItypeGenericFunction(void) const { return ItypeGenericFunction; }
 
   ArrayRef<TypedefDecl *> typeVariables() const {
     return { TypeVarInfo, getNumTypeVars() };
@@ -633,6 +646,8 @@ class DeclSpec {
     FS_checkedLoc = SourceLocation();
     FS_forany_specified = false;
     FS_foranyLoc = SourceLocation();
+    FS_itypeforany_specified = false;
+    FS_itypeforanyloc= SourceLocation();
   }
 
   /// \brief Return true if any type-specifier has been found.
@@ -742,6 +757,8 @@ class DeclSpec {
                                 unsigned &DiagID);
   bool setFunctionSpecForany(SourceLocation Loc, const char *&PrevSpec,
                                 unsigned &DiagID);
+  bool setFunctionSpecItypeforany(SourceLocation Loc, const char *&PrevSpec,
+                                    unsigned &DiagID);
   bool SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
                      unsigned &DiagID);
   bool setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,

include/clang/Sema/Scope.h

@@ -139,7 +139,10 @@ class Scope {
     UncheckedScope = 0x2000000,
 
     /// Checked C - _For_any Polymorphic type scopes
-    ForanyScope = 0x4000000
+    ForanyScope = 0x4000000,
+
+    /// Checked C - _Itype_for_any Polymorphic bounds safe interface type scopes
+    ItypeforanyScope = 0x8000000
 
   };
 private:
@@ -347,6 +350,9 @@ class Scope {
   /// isForanyScope - Return true if this scope is _For_any scope.
   bool isForanyScope() const { return (getFlags() & Scope::ForanyScope); }
 
+  /// isItypeforanyScope - Return true if this scope is _Itype_for_any scope.
+  bool isItypeforanyScope() const { return (getFlags() & Scope::ItypeforanyScope); }
+
   /// isInCXXInlineMethodScope - Return true if this scope is a C++ inline
   /// method scope or is inside one.
   bool isInCXXInlineMethodScope() const {