[mlir][emitc] Adapt to move of FuncOp

mlir/docs/Dialects/emitc.md

 translating the following operations:
 
 *   'cf' Dialect
     *   `cf.br`
     *   `cf.cond_br`
 *   'func' Dialect
     *   `func.call`
     *   `func.constant`
+    *   `func.func`
     *   `func.return`
 *   'scf' Dialect
     *   `scf.for`
     *   `scf.if`
     *   `scf.yield`
 *   'arith' Dialect
     *   `arith.constant`

mlir/lib/Target/Cpp/TranslateToCpp.cpp

static LogicalResult printOperation(CppEmitter &emitter, ModuleOp moduleOp) {
 
   for (Operation &op : moduleOp) {
     if (failed(emitter.emitOperation(op, /*trailingSemicolon=*/false)))
       return failure();
   }
   return success();
 }
 
-static LogicalResult printOperation(CppEmitter &emitter, FuncOp functionOp) {
+static LogicalResult printOperation(CppEmitter &emitter,
+                                    func::FuncOp functionOp) {
   // We need to declare variables at top if the function has multiple blocks.
   if (!emitter.shouldDeclareVariablesAtTop() &&
       functionOp.getBlocks().size() > 1) {
     return functionOp.emitOpError(
         "with multiple blocks needs variables declared at top");
   }
 
   CppEmitter::Scope scope(emitter);
LogicalResult CppEmitter::emitLabel(Block &block) {
   os.getOStream() << getOrCreateName(block) << ":\n";
   return success();
 }
 
 LogicalResult CppEmitter::emitOperation(Operation &op, bool trailingSemicolon) {
   LogicalResult status =
       llvm::TypeSwitch<Operation *, LogicalResult>(&op)
           // Builtin ops.
-          .Case<FuncOp, ModuleOp>(
-              [&](auto op) { return printOperation(*this, op); })
+          .Case<ModuleOp>([&](auto op) { return printOperation(*this, op); })
           // CF ops.
           .Case<cf::BranchOp, cf::CondBranchOp>(
               [&](auto op) { return printOperation(*this, op); })
           // EmitC ops.
           .Case<emitc::ApplyOp, emitc::CallOp, emitc::ConstantOp,
                 emitc::IncludeOp, emitc::VariableOp>(
               [&](auto op) { return printOperation(*this, op); })
           // Func ops.
-          .Case<func::CallOp, func::ConstantOp, func::ReturnOp>(
+          .Case<func::CallOp, func::ConstantOp, func::FuncOp, func::ReturnOp>(
               [&](auto op) { return printOperation(*this, op); })
           // SCF ops.
           .Case<scf::ForOp, scf::IfOp, scf::YieldOp>(
               [&](auto op) { return printOperation(*this, op); })
           // Arithmetic ops.
           .Case<arith::ConstantOp>(
               [&](auto op) { return printOperation(*this, op); })
           .Default([&](Operation *) {