Fix static analyzer tool remarks about unchecked return values

[Manna]

Summary

Reported by Coverity:

Unchecked return value
If the function returns an error value, the error value may be mistaken for a normal value.

1. Inside "Parser.cpp" file, in clang::​Parser::​ParseKNRParamDeclarations(clang::​Declarator &): Value returned from a function is not checked for errors before being used.

check_return: Calling TryConsumeToken without checking return value (as is done elsewhere 75 out of 86 times).

2. Inside "CallGraph.h" file, in clang::​CallGraph::​addToCallGraph(clang::​Decl *): Value returned from a function is not checked for errors before being used.

check_return: Calling TraverseDecl without checking return value (as is done elsewhere 22 out of 23 times).

3. Inside "SemaExpr.cpp" file, in clang::​Sema::​BuildCXXDefaultArgExpr(clang::​SourceLocation, clang::​FunctionDecl *, clang::​ParmVarDecl *, clang::​Expr *): Value returned from a function is not checked for errors before being used.

check_return: Calling TraverseDecl without checking return value (as is done elsewhere 29 out of 31 times)

4. Inside "CGStmt.cpp" file, in clang::​CodeGen::​CodeGenFunction::​EmitAsmInput(clang::​TargetInfo::​ConstraintInfo const &, clang::​Expr const *, std::​__cxx11::​basic_string<char, std::​char_traits<char>, std::​allocator<char>> &): Value returned from a function is not checked for errors before being used.

check_return: Calling EvaluateAsRValue without checking return value (as is done elsewhere 21 out of 25 times).

5. Inside "SemaChecking.cpp" file, in clang::​Sema::​CheckRISCVBuiltinFunctionCall(clang::​TargetInfo const &, unsigned int, clang::​CallExpr *): Value returned from a function is not checked for errors before being used.

check_return: Calling consume_front without checking return value (as is done elsewhere 180 out of 213 times)

[Manna]

Abandoning this revision.

clang/include/clang/Analysis/CallGraph.h

public:
   CallGraph();
   ~CallGraph();
 
   /// Populate the call graph with the functions in the given
   /// declaration.
   ///
   /// Recursively walks the declaration to find all the dependent Decls as well.
   void addToCallGraph(Decl *D) {
-    TraverseDecl(D);
+    (void)TraverseDecl(D);
   }
 
   /// Determine if a declaration should be included in the graph.
   static bool includeInGraph(const Decl *D);
 
   /// Determine if a declaration should be included in the graph for the 
   /// purposes of being a callee. This is similar to includeInGraph except
   /// it permits declarations, not just definitions.

clang/lib/CodeGen/CGStmt.cpp

 CodeGenFunction::EmitAsmInput(const TargetInfo::ConstraintInfo &Info,
                               const Expr *InputExpr,
                               std::string &ConstraintStr) {
   // If this can't be a register or memory, i.e., has to be a constant
   // (immediate or symbolic), try to emit it as such.
   if (!Info.allowsRegister() && !Info.allowsMemory()) {
     if (Info.requiresImmediateConstant()) {
       Expr::EvalResult EVResult;
-      InputExpr->EvaluateAsRValue(EVResult, getContext(), true);
+      InputExpr->(void)EvaluateAsRValue(EVResult, getContext(), true);
 
       llvm::APSInt IntResult;
       if (EVResult.Val.toIntegralConstant(IntResult, InputExpr->getType(),
                                           getContext()))
         return {llvm::ConstantInt::get(getLLVMContext(), IntResult), nullptr};
     }
 
     Expr::EvalResult Result;

clang/lib/Parse/Parser.cpp

while (isDeclarationSpecifier(ImplicitTypenameContext::No)) {
 
     // Consume ';' and continue parsing.
     if (!ExpectAndConsumeSemi(diag::err_expected_semi_declaration))
       continue;
 
     // Otherwise recover by skipping to next semi or mandatory function body.
     if (SkipUntil(tok::l_brace, StopAtSemi | StopBeforeMatch))
       break;
-    TryConsumeToken(tok::semi);
+    (void)TryConsumeToken(tok::semi);
   }
 
   // The actions module must verify that all arguments were declared.
   Actions.ActOnFinishKNRParamDeclarations(getCurScope(), D, Tok.getLocation());
 }
 
 
 /// ParseAsmStringLiteral - This is just a normal string-literal, but is not

clang/lib/Sema/SemaChecking.cpp

if (llvm::none_of(ReqOpFeatures,
         }
         if (OF == "32bit") {
           assert(ReqOpFeatures.size() == 1 && "Expected '32bit' to be alone");
           OF = "RV32";
           IsExtension = false;
         }
 
         // Convert features like "zbr" and "experimental-zbr" to "Zbr".
-        OF.consume_front("experimental-");
+        OF.(void)consume_front("experimental-");
         std::string FeatureStr = OF.str();
         FeatureStr[0] = std::toupper(FeatureStr[0]);
         // Combine strings.
         FeatureStrs += FeatureStrs.empty() ? "" : ", ";
         FeatureStrs += "'";
         FeatureStrs += FeatureStr;
         FeatureStrs += "'";
       }

clang/lib/Sema/SemaExpr.cpp

if (Param->hasUninstantiatedDefaultArg()) {
         return ExprError();
     }
     // CWG2631
     // An immediate invocation that is not evaluated where it appears is
     // evaluated and checked for whether it is a constant expression at the
     // point where the enclosing initializer is used in a function call.
     ImmediateCallVisitor V;
     if (!NestedDefaultChecking)
-      V.TraverseDecl(Param);
+      V.(void)TraverseDecl(Param);
     if (V.HasImmediateCalls) {
       ExprEvalContexts.back().DelayedDefaultInitializationContext = {
           CallLoc, Param, CurContext};
       EnsureImmediateInvocationInDefaultArgs Immediate(*this);
       ExprResult Res = Immediate.TransformInitializer(Param->getInit(),
                                                       /*NotCopy=*/false);
       if (Res.isInvalid())
         return ExprError();