return absl::OkStatus();
  }

  Status RegisterFunction(AbstractFunction* func) override {
    return errors::Unimplemented(
        "Registering graph functions has not been implemented yet.");
  }

  Status RemoveFunction(const string& func) override {
    return errors::Unimplemented(
        "GraphContext::RemoveFunction has not been implemented yet.");
  }
  // For LLVM style RTTI.

  std::string saved_model_dir(dirname);
  std::unique_ptr<tensorflow::SavedModelAPI> result;

  if (tensorflow::unwrap(ctx)->UsesTFRT()) {
    status->status = tensorflow::errors::Unimplemented(
        "TFRT SavedModel implementation will be added in the future");
  } else {
    std::unique_ptr<tensorflow::TFSavedModelAPI> saved_model;
    status->status = tensorflow::TFSavedModelAPI::Load(

// This has to be done as a package rather than as a file,
// because run.go runs files with 'go run', which passes the
// -complete flag to compiler, causing it to complain about
// the intentionally unimplemented function fail.

    for (const auto& t : signature.tuple()) {
      if (t.type() != TaggedValue::Type::TENSOR_SPEC) {
        break;
      }
    }
    return ::tensorflow::OkStatus();
  }
  return tensorflow::errors::Unimplemented(
      "Only functions with inputs/outputs containing a single tensor or a tuple"
      " of tensors are supported right now.");
}

Status VerifySupportedArgs(TaggedValue args) {

    case AttrValue::kList:
      if (attr_.full_type() == "list(string)" &&
          attr_value.list().s_size() == 0) {
        return "{}";
      }
      LOG(WARNING) << "Unimplemented: default value of list-typed attribute.";
      return "/* UNIMPLEMENTED */";
    case AttrValue::kShape:
    case AttrValue::kTensor:
    case AttrValue::kFunc:
    case AttrValue::kPlaceholder:

      continue;
    }
    if (mlir::isa<mlir::AffineMapAttr>(attr)) {
      // AffineMapAttr is not implemented.
      return errors::Unimplemented("AffineMap attribute (needed for '",
                                   name_strref, "') unimplemented");
    }
    TF_RETURN_IF_ERROR(
        llvm::TypeSwitch<mlir::Attribute, Status>(attr)
            .Case<mlir::BoolAttr, mlir::IntegerAttr, mlir::FloatAttr,

// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

func fail() // unimplemented, to test dead code elimination

// Test dead code elimination in if statements
func init() {
	if false {
		fail()
	}
	if 0 == 1 {
		fail()
	}
}

// Test dead code elimination in ordinary switch statements
func init() {

		ldr.Errorf(s, "unimplemented S390x relocation: %v", r.Type()-objabi.ElfRelocOffset)
		return false

	case objabi.ElfRelocOffset + objabi.RelocType(elf.R_390_GLOB_DAT):
		ldr.Errorf(s, "unimplemented S390x relocation: %v", r.Type()-objabi.ElfRelocOffset)
		return false

	case objabi.ElfRelocOffset + objabi.RelocType(elf.R_390_JMP_SLOT):

        TF_ASSIGN_OR_RETURN(auto attr, ConvertTensorProto(item, builder));
        attrs.push_back(attr);
      }
      if (!value.list().func().empty()) {
        return tensorflow::errors::Unimplemented(
            absl::StrCat("Attribute ", value.DebugString()));
      }
      return builder->getArrayAttr(llvm::ArrayRef(attrs.begin(), attrs.end()));
    }
    case AttrValue::VALUE_NOT_SET:

	return nil, status.Errorf(codes.Unimplemented, "method Echo not implemented")
}
func (UnimplementedEchoTestServiceServer) ForwardEcho(context.Context, *ForwardEchoRequest) (*ForwardEchoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ForwardEcho not implemented")
}