Remove Go debugger plugin

In January Davide sent an e-mail to the mailing list to suggest removing
unmaintained language plugins such as Go and Java. The plan was to have
some cool down period to allow users to speak up, however after that the
plugins were never actually removed.

This patch removes the Go debugger plugin.

The plugin can be added again in the future if it is mature enough both
in terms of testing and maintenance commitment.

Discussion on the mailing list:
http://lists.llvm.org/pipermail/lldb-dev/2018-January/013171.html

Differential revision: https://reviews.llvm.org/D54057

llvm-svn: 346157

1 files changed, 0 insertions, 668 deletions

diff --git a/lldb/source/Plugins/ExpressionParser/Go/GoUserExpression.cpp b/lldb/source/Plugins/ExpressionParser/Go/GoUserExpression.cpp
deleted file mode 100644
index 3a10a1dc767..00000000000
--- a/lldb/source/Plugins/ExpressionParser/Go/GoUserExpression.cpp
+++ /dev/null
@@ -1,668 +0,0 @@
-//===-- GoUserExpression.cpp ------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// C Includes
-#include <stdio.h>
-#if HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-
-// C++ Includes
-#include <cstdlib>
-#include <memory>
-#include <string>
-#include <vector>
-
-// Other libraries and framework includes
-#include "llvm/ADT/StringMap.h"
-#include "llvm/ADT/StringRef.h"
-
-// Project includes
-#include "GoUserExpression.h"
-
-#include "lldb/Core/Module.h"
-#include "lldb/Core/StreamFile.h"
-#include "lldb/Core/ValueObjectConstResult.h"
-#include "lldb/Core/ValueObjectRegister.h"
-#include "lldb/Expression/DiagnosticManager.h"
-#include "lldb/Expression/ExpressionVariable.h"
-#include "lldb/Symbol/GoASTContext.h"
-#include "lldb/Symbol/SymbolFile.h"
-#include "lldb/Symbol/TypeList.h"
-#include "lldb/Symbol/VariableList.h"
-#include "lldb/Target/ExecutionContext.h"
-#include "lldb/Target/Process.h"
-#include "lldb/Target/RegisterContext.h"
-#include "lldb/Target/StackFrame.h"
-#include "lldb/Target/Target.h"
-#include "lldb/Target/ThreadPlan.h"
-#include "lldb/Target/ThreadPlanCallUserExpression.h"
-#include "lldb/Utility/ConstString.h"
-#include "lldb/Utility/DataBufferHeap.h"
-#include "lldb/Utility/DataEncoder.h"
-#include "lldb/Utility/DataExtractor.h"
-#include "lldb/Utility/Log.h"
-#include "lldb/Utility/StreamString.h"
-#include "lldb/lldb-private.h"
-
-#include "Plugins/ExpressionParser/Go/GoAST.h"
-#include "Plugins/ExpressionParser/Go/GoParser.h"
-
-using namespace lldb_private;
-using namespace lldb;
-
-class GoUserExpression::GoInterpreter {
-public:
-  GoInterpreter(ExecutionContext &exe_ctx, const char *expr)
-      : m_exe_ctx(exe_ctx), m_frame(exe_ctx.GetFrameSP()), m_parser(expr) {
-    if (m_frame) {
-      const SymbolContext &ctx =
-          m_frame->GetSymbolContext(eSymbolContextFunction);
-      ConstString fname = ctx.GetFunctionName();
-      if (fname.GetLength() > 0) {
-        size_t dot = fname.GetStringRef().find('.');
-        if (dot != llvm::StringRef::npos)
-          m_package = llvm::StringRef(fname.AsCString(), dot);
-      }
-    }
-  }
-
-  void set_use_dynamic(DynamicValueType use_dynamic) {
-    m_use_dynamic = use_dynamic;
-  }
-
-  bool Parse();
-  lldb::ValueObjectSP Evaluate(ExecutionContext &exe_ctx);
-  lldb::ValueObjectSP EvaluateStatement(const GoASTStmt *s);
-  lldb::ValueObjectSP EvaluateExpr(const GoASTExpr *e);
-
-  ValueObjectSP VisitBadExpr(const GoASTBadExpr *e) {
-    m_parser.GetError(m_error);
-    return nullptr;
-  }
-
-  ValueObjectSP VisitParenExpr(const GoASTParenExpr *e);
-  ValueObjectSP VisitIdent(const GoASTIdent *e);
-  ValueObjectSP VisitStarExpr(const GoASTStarExpr *e);
-  ValueObjectSP VisitSelectorExpr(const GoASTSelectorExpr *e);
-  ValueObjectSP VisitBasicLit(const GoASTBasicLit *e);
-  ValueObjectSP VisitIndexExpr(const GoASTIndexExpr *e);
-  ValueObjectSP VisitUnaryExpr(const GoASTUnaryExpr *e);
-  ValueObjectSP VisitCallExpr(const GoASTCallExpr *e);
-
-  ValueObjectSP VisitTypeAssertExpr(const GoASTTypeAssertExpr *e) {
-    return NotImplemented(e);
-  }
-
-  ValueObjectSP VisitBinaryExpr(const GoASTBinaryExpr *e) {
-    return NotImplemented(e);
-  }
-
-  ValueObjectSP VisitArrayType(const GoASTArrayType *e) {
-    return NotImplemented(e);
-  }
-
-  ValueObjectSP VisitChanType(const GoASTChanType *e) {
-    return NotImplemented(e);
-  }
-
-  ValueObjectSP VisitCompositeLit(const GoASTCompositeLit *e) {
-    return NotImplemented(e);
-  }
-
-  ValueObjectSP VisitEllipsis(const GoASTEllipsis *e) {
-    return NotImplemented(e);
-  }
-
-  ValueObjectSP VisitFuncType(const GoASTFuncType *e) {
-    return NotImplemented(e);
-  }
-
-  ValueObjectSP VisitFuncLit(const GoASTFuncLit *e) {
-    return NotImplemented(e);
-  }
-
-  ValueObjectSP VisitInterfaceType(const GoASTInterfaceType *e) {
-    return NotImplemented(e);
-  }
-
-  ValueObjectSP VisitKeyValueExpr(const GoASTKeyValueExpr *e) {
-    return NotImplemented(e);
-  }
-
-  ValueObjectSP VisitMapType(const GoASTMapType *e) {
-    return NotImplemented(e);
-  }
-
-  ValueObjectSP VisitSliceExpr(const GoASTSliceExpr *e) {
-    return NotImplemented(e);
-  }
-
-  ValueObjectSP VisitStructType(const GoASTStructType *e) {
-    return NotImplemented(e);
-  }
-
-  CompilerType EvaluateType(const GoASTExpr *e);
-
-  Status &error() { return m_error; }
-
-private:
-  std::nullptr_t NotImplemented(const GoASTExpr *e) {
-    m_error.SetErrorStringWithFormat("%s node not implemented",
-                                     e->GetKindName());
-    return nullptr;
-  }
-
-  ExecutionContext m_exe_ctx;
-  lldb::StackFrameSP m_frame;
-  GoParser m_parser;
-  DynamicValueType m_use_dynamic;
-  Status m_error;
-  llvm::StringRef m_package;
-  std::vector<std::unique_ptr<GoASTStmt>> m_statements;
-};
-
-VariableSP FindGlobalVariable(TargetSP target, llvm::Twine name) {
-  ConstString fullname(name.str());
-  VariableList variable_list;
-  if (!target) {
-    return nullptr;
-  }
-  const uint32_t match_count =
-      target->GetImages().FindGlobalVariables(fullname, 1, variable_list);
-  if (match_count == 1) {
-    return variable_list.GetVariableAtIndex(0);
-  }
-  return nullptr;
-}
-
-CompilerType LookupType(TargetSP target, ConstString name) {
-  if (!target)
-    return CompilerType();
-  SymbolContext sc;
-  TypeList type_list;
-  llvm::DenseSet<SymbolFile *> searched_symbol_files;
-  uint32_t num_matches = target->GetImages().FindTypes(
-      sc, name, false, 2, searched_symbol_files, type_list);
-  if (num_matches > 0) {
-    return type_list.GetTypeAtIndex(0)->GetFullCompilerType();
-  }
-  return CompilerType();
-}
-
-GoUserExpression::GoUserExpression(ExecutionContextScope &exe_scope,
-                                   llvm::StringRef expr, llvm::StringRef prefix,
-                                   lldb::LanguageType language,
-                                   ResultType desired_type,
-                                   const EvaluateExpressionOptions &options)
-    : UserExpression(exe_scope, expr, prefix, language, desired_type, options) {
-}
-
-bool GoUserExpression::Parse(DiagnosticManager &diagnostic_manager,
-                             ExecutionContext &exe_ctx,
-                             lldb_private::ExecutionPolicy execution_policy,
-                             bool keep_result_in_memory,
-                             bool generate_debug_info) {
-  InstallContext(exe_ctx);
-  m_interpreter.reset(new GoInterpreter(exe_ctx, GetUserText()));
-  if (m_interpreter->Parse())
-    return true;
-  const char *error_cstr = m_interpreter->error().AsCString();
-  if (error_cstr && error_cstr[0])
-    diagnostic_manager.PutString(eDiagnosticSeverityError, error_cstr);
-  else
-    diagnostic_manager.Printf(eDiagnosticSeverityError,
-                              "expression can't be interpreted or run");
-  return false;
-}
-
-lldb::ExpressionResults
-GoUserExpression::DoExecute(DiagnosticManager &diagnostic_manager,
-                            ExecutionContext &exe_ctx,
-                            const EvaluateExpressionOptions &options,
-                            lldb::UserExpressionSP &shared_ptr_to_me,
-                            lldb::ExpressionVariableSP &result) {
-  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS |
-                                                  LIBLLDB_LOG_STEP));
-
-  lldb_private::ExecutionPolicy execution_policy = options.GetExecutionPolicy();
-  lldb::ExpressionResults execution_results = lldb::eExpressionSetupError;
-
-  Process *process = exe_ctx.GetProcessPtr();
-  Target *target = exe_ctx.GetTargetPtr();
-
-  if (target == nullptr || process == nullptr ||
-      process->GetState() != lldb::eStateStopped) {
-    if (execution_policy == eExecutionPolicyAlways) {
-      if (log)
-        log->Printf("== [GoUserExpression::Evaluate] Expression may not run, "
-                    "but is not constant ==");
-
-      diagnostic_manager.PutString(eDiagnosticSeverityError,
-                                   "expression needed to run but couldn't");
-
-      return execution_results;
-    }
-  }
-
-  m_interpreter->set_use_dynamic(options.GetUseDynamic());
-  ValueObjectSP result_val_sp = m_interpreter->Evaluate(exe_ctx);
-  Status err = m_interpreter->error();
-  m_interpreter.reset();
-
-  if (!result_val_sp) {
-    const char *error_cstr = err.AsCString();
-    if (error_cstr && error_cstr[0])
-      diagnostic_manager.PutString(eDiagnosticSeverityError, error_cstr);
-    else
-      diagnostic_manager.PutString(eDiagnosticSeverityError,
-                                   "expression can't be interpreted or run");
-    return lldb::eExpressionDiscarded;
-  }
-  result.reset(new ExpressionVariable(ExpressionVariable::eKindGo));
-  result->m_live_sp = result->m_frozen_sp = result_val_sp;
-  result->m_flags |= ExpressionVariable::EVIsProgramReference;
-  PersistentExpressionState *pv =
-      target->GetPersistentExpressionStateForLanguage(eLanguageTypeGo);
-  if (pv != nullptr) {
-    result->SetName(pv->GetNextPersistentVariableName(
-        *target, pv->GetPersistentVariablePrefix()));
-    pv->AddVariable(result);
-  }
-  return lldb::eExpressionCompleted;
-}
-
-bool GoUserExpression::GoInterpreter::Parse() {
-  for (std::unique_ptr<GoASTStmt> stmt(m_parser.Statement()); stmt;
-       stmt.reset(m_parser.Statement())) {
-    if (m_parser.Failed())
-      break;
-    m_statements.emplace_back(std::move(stmt));
-  }
-  if (m_parser.Failed() || !m_parser.AtEOF())
-    m_parser.GetError(m_error);
-
-  return m_error.Success();
-}
-
-ValueObjectSP
-GoUserExpression::GoInterpreter::Evaluate(ExecutionContext &exe_ctx) {
-  m_exe_ctx = exe_ctx;
-  ValueObjectSP result;
-  for (const std::unique_ptr<GoASTStmt> &stmt : m_statements) {
-    result = EvaluateStatement(stmt.get());
-    if (m_error.Fail())
-      return nullptr;
-  }
-  return result;
-}
-
-ValueObjectSP GoUserExpression::GoInterpreter::EvaluateStatement(
-    const lldb_private::GoASTStmt *stmt) {
-  ValueObjectSP result;
-  switch (stmt->GetKind()) {
-  case GoASTNode::eBlockStmt: {
-    const GoASTBlockStmt *block = llvm::cast<GoASTBlockStmt>(stmt);
-    for (size_t i = 0; i < block->NumList(); ++i)
-      result = EvaluateStatement(block->GetList(i));
-    break;
-  }
-  case GoASTNode::eBadStmt:
-    m_parser.GetError(m_error);
-    break;
-  case GoASTNode::eExprStmt: {
-    const GoASTExprStmt *expr = llvm::cast<GoASTExprStmt>(stmt);
-    return EvaluateExpr(expr->GetX());
-  }
-  default:
-    m_error.SetErrorStringWithFormat("%s node not supported",
-                                     stmt->GetKindName());
-  }
-  return result;
-}
-
-ValueObjectSP GoUserExpression::GoInterpreter::EvaluateExpr(
-    const lldb_private::GoASTExpr *e) {
-  if (e)
-    return e->Visit<ValueObjectSP>(this);
-  return ValueObjectSP();
-}
-
-ValueObjectSP GoUserExpression::GoInterpreter::VisitParenExpr(
-    const lldb_private::GoASTParenExpr *e) {
-  return EvaluateExpr(e->GetX());
-}
-
-ValueObjectSP GoUserExpression::GoInterpreter::VisitIdent(const GoASTIdent *e) {
-  ValueObjectSP val;
-  if (m_frame) {
-    VariableSP var_sp;
-    std::string varname = e->GetName().m_value.str();
-    if (varname.size() > 1 && varname[0] == '$') {
-      RegisterContextSP reg_ctx_sp = m_frame->GetRegisterContext();
-      const RegisterInfo *reg =
-          reg_ctx_sp->GetRegisterInfoByName(varname.c_str() + 1);
-      if (reg) {
-        std::string type;
-        switch (reg->encoding) {
-        case lldb::eEncodingSint:
-          type.append("int");
-          break;
-        case lldb::eEncodingUint:
-          type.append("uint");
-          break;
-        case lldb::eEncodingIEEE754:
-          type.append("float");
-          break;
-        default:
-          m_error.SetErrorString("Invalid register encoding");
-          return nullptr;
-        }
-        switch (reg->byte_size) {
-        case 8:
-          type.append("64");
-          break;
-        case 4:
-          type.append("32");
-          break;
-        case 2:
-          type.append("16");
-          break;
-        case 1:
-          type.append("8");
-          break;
-        default:
-          m_error.SetErrorString("Invalid register size");
-          return nullptr;
-        }
-        ValueObjectSP regVal = ValueObjectRegister::Create(
-            m_frame.get(), reg_ctx_sp, reg->kinds[eRegisterKindLLDB]);
-        CompilerType goType =
-            LookupType(m_frame->CalculateTarget(), ConstString(type));
-        if (regVal) {
-          regVal = regVal->Cast(goType);
-          return regVal;
-        }
-      }
-      m_error.SetErrorString("Invalid register name");
-      return nullptr;
-    }
-    VariableListSP var_list_sp(m_frame->GetInScopeVariableList(false));
-    if (var_list_sp) {
-      var_sp = var_list_sp->FindVariable(ConstString(varname));
-      if (var_sp)
-        val = m_frame->GetValueObjectForFrameVariable(var_sp, m_use_dynamic);
-      else {
-        // When a variable is on the heap instead of the stack, go records a
-        // variable '&x' instead of 'x'.
-        var_sp = var_list_sp->FindVariable(ConstString("&" + varname));
-        if (var_sp) {
-          val = m_frame->GetValueObjectForFrameVariable(var_sp, m_use_dynamic);
-          if (val)
-            val = val->Dereference(m_error);
-          if (m_error.Fail())
-            return nullptr;
-        }
-      }
-    }
-    if (!val) {
-      m_error.Clear();
-      TargetSP target = m_frame->CalculateTarget();
-      if (!target) {
-        m_error.SetErrorString("No target");
-        return nullptr;
-      }
-      var_sp =
-          FindGlobalVariable(target, m_package + "." + e->GetName().m_value);
-      if (var_sp)
-        return m_frame->TrackGlobalVariable(var_sp, m_use_dynamic);
-    }
-  }
-  if (!val)
-    m_error.SetErrorStringWithFormat("Unknown variable %s",
-                                     e->GetName().m_value.str().c_str());
-  return val;
-}
-
-ValueObjectSP
-GoUserExpression::GoInterpreter::VisitStarExpr(const GoASTStarExpr *e) {
-  ValueObjectSP target = EvaluateExpr(e->GetX());
-  if (!target)
-    return nullptr;
-  return target->Dereference(m_error);
-}
-
-ValueObjectSP GoUserExpression::GoInterpreter::VisitSelectorExpr(
-    const lldb_private::GoASTSelectorExpr *e) {
-  ValueObjectSP target = EvaluateExpr(e->GetX());
-  if (target) {
-    if (target->GetCompilerType().IsPointerType()) {
-      target = target->Dereference(m_error);
-      if (m_error.Fail())
-        return nullptr;
-    }
-    ConstString field(e->GetSel()->GetName().m_value);
-    ValueObjectSP result = target->GetChildMemberWithName(field, true);
-    if (!result)
-      m_error.SetErrorStringWithFormat("Unknown child %s", field.AsCString());
-    return result;
-  }
-  if (const GoASTIdent *package = llvm::dyn_cast<GoASTIdent>(e->GetX())) {
-    if (VariableSP global = FindGlobalVariable(
-            m_exe_ctx.GetTargetSP(), package->GetName().m_value + "." +
-                                         e->GetSel()->GetName().m_value)) {
-      if (m_frame) {
-        m_error.Clear();
-        return m_frame->GetValueObjectForFrameVariable(global, m_use_dynamic);
-      }
-    }
-  }
-  if (const GoASTBasicLit *packageLit =
-          llvm::dyn_cast<GoASTBasicLit>(e->GetX())) {
-    if (packageLit->GetValue().m_type == GoLexer::LIT_STRING) {
-      std::string value = packageLit->GetValue().m_value.str();
-      value = value.substr(1, value.size() - 2);
-      if (VariableSP global = FindGlobalVariable(
-              m_exe_ctx.GetTargetSP(),
-              value + "." + e->GetSel()->GetName().m_value)) {
-        if (m_frame) {
-          m_error.Clear();
-          return m_frame->TrackGlobalVariable(global, m_use_dynamic);
-        }
-      }
-    }
-  }
-  // EvaluateExpr should have already set m_error.
-  return target;
-}
-
-ValueObjectSP GoUserExpression::GoInterpreter::VisitBasicLit(
-    const lldb_private::GoASTBasicLit *e) {
-  std::string value = e->GetValue().m_value.str();
-  if (e->GetValue().m_type != GoLexer::LIT_INTEGER) {
-    m_error.SetErrorStringWithFormat("Unsupported literal %s", value.c_str());
-    return nullptr;
-  }
-  errno = 0;
-  int64_t intvalue = strtol(value.c_str(), nullptr, 0);
-  if (errno != 0) {
-    m_error.SetErrorToErrno();
-    return nullptr;
-  }
-  DataBufferSP buf(new DataBufferHeap(sizeof(intvalue), 0));
-  TargetSP target = m_exe_ctx.GetTargetSP();
-  if (!target) {
-    m_error.SetErrorString("No target");
-    return nullptr;
-  }
-  ByteOrder order = target->GetArchitecture().GetByteOrder();
-  uint8_t addr_size = target->GetArchitecture().GetAddressByteSize();
-  DataEncoder enc(buf, order, addr_size);
-  enc.PutU64(0, static_cast<uint64_t>(intvalue));
-  DataExtractor data(buf, order, addr_size);
-
-  CompilerType type = LookupType(target, ConstString("int64"));
-  return ValueObject::CreateValueObjectFromData(llvm::StringRef(), data,
-                                                m_exe_ctx, type);
-}
-
-ValueObjectSP GoUserExpression::GoInterpreter::VisitIndexExpr(
-    const lldb_private::GoASTIndexExpr *e) {
-  ValueObjectSP target = EvaluateExpr(e->GetX());
-  if (!target)
-    return nullptr;
-  ValueObjectSP index = EvaluateExpr(e->GetIndex());
-  if (!index)
-    return nullptr;
-  bool is_signed;
-  if (!index->GetCompilerType().IsIntegerType(is_signed)) {
-    m_error.SetErrorString("Unsupported index");
-    return nullptr;
-  }
-  size_t idx;
-  if (is_signed)
-    idx = index->GetValueAsSigned(0);
-  else
-    idx = index->GetValueAsUnsigned(0);
-  if (GoASTContext::IsGoSlice(target->GetCompilerType())) {
-    target = target->GetStaticValue();
-    ValueObjectSP cap =
-        target->GetChildMemberWithName(ConstString("cap"), true);
-    if (cap) {
-      uint64_t capval = cap->GetValueAsUnsigned(0);
-      if (idx >= capval) {
-        m_error.SetErrorStringWithFormat("Invalid index %" PRIu64
-                                         " , cap = %" PRIu64,
-                                         uint64_t(idx), capval);
-        return nullptr;
-      }
-    }
-    target = target->GetChildMemberWithName(ConstString("array"), true);
-    if (target && m_use_dynamic != eNoDynamicValues) {
-      ValueObjectSP dynamic = target->GetDynamicValue(m_use_dynamic);
-      if (dynamic)
-        target = dynamic;
-    }
-    if (!target)
-      return nullptr;
-    return target->GetSyntheticArrayMember(idx, true);
-  }
-  return target->GetChildAtIndex(idx, true);
-}
-
-ValueObjectSP
-GoUserExpression::GoInterpreter::VisitUnaryExpr(const GoASTUnaryExpr *e) {
-  ValueObjectSP x = EvaluateExpr(e->GetX());
-  if (!x)
-    return nullptr;
-  switch (e->GetOp()) {
-  case GoLexer::OP_AMP: {
-    CompilerType type = x->GetCompilerType().GetPointerType();
-    uint64_t address = x->GetAddressOf();
-    return ValueObject::CreateValueObjectFromAddress(llvm::StringRef(), address,
-                                                     m_exe_ctx, type);
-  }
-  case GoLexer::OP_PLUS:
-    return x;
-  default:
-    m_error.SetErrorStringWithFormat(
-        "Operator %s not supported",
-        GoLexer::LookupToken(e->GetOp()).str().c_str());
-    return nullptr;
-  }
-}
-
-CompilerType GoUserExpression::GoInterpreter::EvaluateType(const GoASTExpr *e) {
-  TargetSP target = m_exe_ctx.GetTargetSP();
-  if (auto *id = llvm::dyn_cast<GoASTIdent>(e)) {
-    CompilerType result =
-        LookupType(target, ConstString(id->GetName().m_value));
-    if (result.IsValid())
-      return result;
-    std::string fullname = (m_package + "." + id->GetName().m_value).str();
-    result = LookupType(target, ConstString(fullname));
-    if (!result)
-      m_error.SetErrorStringWithFormat("Unknown type %s", fullname.c_str());
-    return result;
-  }
-  if (auto *sel = llvm::dyn_cast<GoASTSelectorExpr>(e)) {
-    std::string package;
-    if (auto *pkg_node = llvm::dyn_cast<GoASTIdent>(sel->GetX())) {
-      package = pkg_node->GetName().m_value.str();
-    } else if (auto *str_node = llvm::dyn_cast<GoASTBasicLit>(sel->GetX())) {
-      if (str_node->GetValue().m_type == GoLexer::LIT_STRING) {
-        package = str_node->GetValue().m_value.substr(1).str();
-        package.resize(package.length() - 1);
-      }
-    }
-    if (package.empty()) {
-      m_error.SetErrorStringWithFormat("Invalid %s in type expression",
-                                       sel->GetX()->GetKindName());
-      return CompilerType();
-    }
-    std::string fullname =
-        (package + "." + sel->GetSel()->GetName().m_value).str();
-    CompilerType result = LookupType(target, ConstString(fullname));
-    if (!result)
-      m_error.SetErrorStringWithFormat("Unknown type %s", fullname.c_str());
-    return result;
-  }
-  if (auto *star = llvm::dyn_cast<GoASTStarExpr>(e)) {
-    CompilerType elem = EvaluateType(star->GetX());
-    return elem.GetPointerType();
-  }
-  if (auto *paren = llvm::dyn_cast<GoASTParenExpr>(e))
-    return EvaluateType(paren->GetX());
-  if (auto *array = llvm::dyn_cast<GoASTArrayType>(e)) {
-    CompilerType elem = EvaluateType(array->GetElt());
-  }
-
-  m_error.SetErrorStringWithFormat("Invalid %s in type expression",
-                                   e->GetKindName());
-  return CompilerType();
-}
-
-ValueObjectSP GoUserExpression::GoInterpreter::VisitCallExpr(
-    const lldb_private::GoASTCallExpr *e) {
-  ValueObjectSP x = EvaluateExpr(e->GetFun());
-  if (x || e->NumArgs() != 1) {
-    m_error.SetErrorStringWithFormat("Code execution not supported");
-    return nullptr;
-  }
-  m_error.Clear();
-  CompilerType type = EvaluateType(e->GetFun());
-  if (!type) {
-    return nullptr;
-  }
-  ValueObjectSP value = EvaluateExpr(e->GetArgs(0));
-  if (!value)
-    return nullptr;
-  // TODO: Handle special conversions
-  return value->Cast(type);
-}
-
-GoPersistentExpressionState::GoPersistentExpressionState()
-    : PersistentExpressionState(eKindGo) {}
-
-void GoPersistentExpressionState::RemovePersistentVariable(
-    lldb::ExpressionVariableSP variable) {
-  RemoveVariable(variable);
-
-  const char *name = variable->GetName().AsCString();
-
-  if (*(name++) != '$')
-    return;
-  if (*(name++) != 'g')
-    return;
-  if (*(name++) != 'o')
-    return;
-
-  if (strtoul(name, nullptr, 0) == m_next_persistent_variable_id - 1)
-    m_next_persistent_variable_id--;
-}