Get rid of "smart" quotes. Per report on cfe-dev.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@78230 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/Analysis/CFRefCount.cpp b/lib/Analysis/CFRefCount.cpp
index eb15644edd69ec2bbcbb7c614b6faca9007d2e65..23482ca4afd04446be417700935aa3bfa867dbc9 100644 (file)
--- a/lib/Analysis/CFRefCount.cpp
+++ b/lib/Analysis/CFRefCount.cpp
@@ -44,7 +44,7 @@ using namespace clang;
 //     MemoryMgmt/Tasks/MemoryManagementRules.html
 //
 // "You take ownership of an object if you create it using a method whose name
-//  begins with “alloc” or “new” or contains “copy” (for example, alloc, 
+//  begins with "alloc" or "new" or contains "copy" (for example, alloc, 
 //  newObject, or mutableCopy), or if you send it a retain message. You are
 //  responsible for relinquishing ownership of objects you own using release
 //  or autorelease. Any other time you receive an object, you must

diff --git a/lib/Sema/SemaDeclCXX.cpp b/lib/Sema/SemaDeclCXX.cpp
index 106c754d7565d6e5846f49afe47163bf4b4f4647..90d02ce3b5fe5d551cd81ecd4024d5f6c3b31dc9 100644 (file)
--- a/lib/Sema/SemaDeclCXX.cpp
+++ b/lib/Sema/SemaDeclCXX.cpp
@@ -1747,8 +1747,8 @@ void Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
                                      FunctionDecl::StorageClass& SC) {
   // C++ [class.conv.fct]p1:
   //   Neither parameter types nor return type can be specified. The
-  //   type of a conversion function (8.3.5) is “function taking no
-  //   parameter returning conversion-type-id.” 
+  //   type of a conversion function (8.3.5) is "function taking no
+  //   parameter returning conversion-type-id." 
   if (SC == FunctionDecl::Static) {
     if (!D.isInvalidType())
       Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
@@ -1974,8 +1974,8 @@ Sema::DeclPtrTy Sema::ActOnUsingDirective(Scope *S,
     //   unqualified name lookup (3.4.1), the names appear as if they
     //   were declared in the nearest enclosing namespace which
     //   contains both the using-directive and the nominated
-    //   namespace. [Note: in this context, “contains” means “contains
-    //   directly or indirectly”. ]
+    //   namespace. [Note: in this context, "contains" means "contains
+    //   directly or indirectly". ]
 
     // Find enclosing context containing both using-directive and
     // nominated namespace.
@@ -2612,8 +2612,8 @@ Sema::CompareReferenceRelationship(QualType T1, QualType T2,
   QualType UnqualT2 = T2.getUnqualifiedType();
 
   // C++ [dcl.init.ref]p4:
-  //   Given types “cv1 T1” and “cv2 T2,” “cv1 T1” is
-  //   reference-related to “cv2 T2” if T1 is the same type as T2, or 
+  //   Given types "cv1 T1" and "cv2 T2," "cv1 T1" is
+  //   reference-related to "cv2 T2" if T1 is the same type as T2, or 
   //   T1 is a base class of T2.
   if (UnqualT1 == UnqualT2)
     DerivedToBase = false;
@@ -2626,7 +2626,7 @@ Sema::CompareReferenceRelationship(QualType T1, QualType T2,
   // least).
 
   // C++ [dcl.init.ref]p4:
-  //   "cv1 T1” is reference-compatible with “cv2 T2” if T1 is
+  //   "cv1 T1" is reference-compatible with "cv2 T2" if T1 is
   //   reference-related to T2 and cv1 is the same cv-qualification
   //   as, or greater cv-qualification than, cv2. For purposes of
   //   overload resolution, cases for which cv1 is greater
@@ -2699,8 +2699,8 @@ Sema::CheckReferenceInit(Expr *&Init, QualType DeclType,
     ICS->ConversionKind = ImplicitConversionSequence::BadConversion;
 
   // C++ [dcl.init.ref]p5:
-  //   A reference to type “cv1 T1” is initialized by an expression
-  //   of type “cv2 T2” as follows:
+  //   A reference to type "cv1 T1" is initialized by an expression
+  //   of type "cv2 T2" as follows:
 
   //     -- If the initializer expression
 
@@ -2717,8 +2717,8 @@ Sema::CheckReferenceInit(Expr *&Init, QualType DeclType,
   }
 
   bool BindsDirectly = false;
-  //       -- is an lvalue (but is not a bit-field), and “cv1 T1” is
-  //          reference-compatible with “cv2 T2,” or
+  //       -- is an lvalue (but is not a bit-field), and "cv1 T1" is
+  //          reference-compatible with "cv2 T2," or
   //
   // Note that the bit-field check is skipped if we are just computing
   // the implicit conversion sequence (C++ [over.best.ics]p2).
@@ -2759,8 +2759,8 @@ Sema::CheckReferenceInit(Expr *&Init, QualType DeclType,
   }
 
   //       -- has a class type (i.e., T2 is a class type) and can be
-  //          implicitly converted to an lvalue of type “cv3 T3,”
-  //          where “cv1 T1” is reference-compatible with “cv3 T3”
+  //          implicitly converted to an lvalue of type "cv3 T3,"
+  //          where "cv1 T1" is reference-compatible with "cv3 T3"
   //          92) (this conversion is selected by enumerating the
   //          applicable conversion functions (13.3.1.6) and choosing
   //          the best one through overload resolution (13.3)),
@@ -2863,15 +2863,15 @@ Sema::CheckReferenceInit(Expr *&Init, QualType DeclType,
   }
 
   //       -- If the initializer expression is an rvalue, with T2 a
-  //          class type, and “cv1 T1” is reference-compatible with
-  //          “cv2 T2,” the reference is bound in one of the
+  //          class type, and "cv1 T1" is reference-compatible with
+  //          "cv2 T2," the reference is bound in one of the
   //          following ways (the choice is implementation-defined):
   //
   //          -- The reference is bound to the object represented by
   //             the rvalue (see 3.10) or to a sub-object within that
   //             object.
   //
-  //          -- A temporary of type “cv1 T2” [sic] is created, and
+  //          -- A temporary of type "cv1 T2" [sic] is created, and
   //             a constructor is called to copy the entire rvalue
   //             object into the temporary. The reference is bound to
   //             the temporary or to a sub-object within the
@@ -2906,7 +2906,7 @@ Sema::CheckReferenceInit(Expr *&Init, QualType DeclType,
     return false;
   }
 
-  //       -- Otherwise, a temporary of type “cv1 T1” is created and
+  //       -- Otherwise, a temporary of type "cv1 T1" is created and
   //          initialized from the initializer expression using the
   //          rules for a non-reference copy initialization (8.5). The
   //          reference is then bound to the temporary. If T1 is

diff --git a/lib/Sema/SemaLookup.cpp b/lib/Sema/SemaLookup.cpp
index 1fd6ae4235752306c948447fb9af41260e475ac6..788111c5dd2c9a10fe40edb9e296a538ff4a630a 100644 (file)
--- a/lib/Sema/SemaLookup.cpp
+++ b/lib/Sema/SemaLookup.cpp
@@ -654,8 +654,8 @@ Sema::CppLookupName(Scope *S, DeclarationName Name,
   // ...During unqualified name lookup (3.4.1), the names appear as if
   // they were declared in the nearest enclosing namespace which contains
   // both the using-directive and the nominated namespace.
-  // [Note: in this context, “contains” means “contains directly or
-  // indirectly”. 
+  // [Note: in this context, "contains" means "contains directly or
+  // indirectly". 
   //
   // For example:
   // namespace A { int i; }
@@ -1687,10 +1687,10 @@ void Sema::LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
   //        unqualified function calls (3.4.2) except that all member
   //        functions are ignored. However, if no operand has a class
   //        type, only those non-member functions in the lookup set
-  //        that have a first parameter of type T1 or “reference to
-  //        (possibly cv-qualified) T1”, when T1 is an enumeration
+  //        that have a first parameter of type T1 or "reference to
+  //        (possibly cv-qualified) T1", when T1 is an enumeration
   //        type, or (if there is a right operand) a second parameter
-  //        of type T2 or “reference to (possibly cv-qualified) T2”,
+  //        of type T2 or "reference to (possibly cv-qualified) T2",
   //        when T2 is an enumeration type, are candidate functions.
   DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
   LookupResult Operators = LookupName(S, OpName, LookupOperatorName);

diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp
index 1e0c057b357b1fbbe9236a2ad59f310540c631ce..8dd84c0b5d2e4462725a730263f012b041cca6c0 100644 (file)
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -4359,7 +4359,7 @@ Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Object,
   
   // C++ [over.call.object]p1:
   //  If the primary-expression E in the function call syntax
-  //  evaluates to a class object of type “cv T”, then the set of
+  //  evaluates to a class object of type "cv T", then the set of
   //  candidate functions includes at least the function call
   //  operators of T. The function call operators of T are obtained by
   //  ordinary lookup of the name operator() in the context of

diff --git a/lib/Sema/SemaType.cpp b/lib/Sema/SemaType.cpp
index 1bb516e7943df7d89904e8131258dbc256be93f2..6ba23a9c102e58e704196983ea53e2f01505264b 100644 (file)
--- a/lib/Sema/SemaType.cpp
+++ b/lib/Sema/SemaType.cpp
@@ -447,7 +447,7 @@ QualType Sema::BuildReferenceType(QualType T, bool LValueRef, unsigned Quals,
   }
 
   // C++ [dcl.ref]p1:
-  //   A declarator that specifies the type “reference to cv void”
+  //   A declarator that specifies the type "reference to cv void"
   //   is ill-formed.
   if (T->isVoidType()) {
     Diag(Loc, diag::err_reference_to_void);