diff --git a/duchain/contextbuilder.cpp b/duchain/contextbuilder.cpp
index 4327089..fbfebe9 100644
--- a/duchain/contextbuilder.cpp
+++ b/duchain/contextbuilder.cpp
@@ -1,88 +1,88 @@
 #include "contextbuilder.h"
 
 #include <language/duchain/parsingenvironment.h>
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 
 #include "rustducontext.h"
 #include "nodetraits.h"
 
 namespace Rust
 {
 
 RSVisitResult visitCallback(RSNode *node, RSNode *parent, void *data);
 
-RangeInRevision ContextBuilder::editorFindSpellingRange(RustNode *node, const Identifier& identifier)
+RangeInRevision ContextBuilder::editorFindSpellingRange(RustNode *node, const QString& identifier)
 {
     RSRange range = node_get_spelling_range(node->data());
     KTextEditor::Range incorrectRange = KTextEditor::Range(range.start.line - 1, range.start.column, INT_MAX, INT_MAX);
     IDocument *document = ICore::self()->documentController()
             ->documentForUrl(topContext()->url().toUrl());
 
     QVector<KTextEditor::Range> ranges;
     if (document) {
-        ranges = document->textDocument()->searchText(incorrectRange, identifier.toString());
+        ranges = document->textDocument()->searchText(incorrectRange, identifier);
     } else {
         ranges = { KTextEditor::Range::invalid() };
     }
 
     return RangeInRevision::castFromSimpleRange(ranges.first());
 }
 
 void ContextBuilder::visitChildren(RustNode *node)
 {
     visit_children(node->data(), visitCallback, this);
 }
 
 void ContextBuilder::startVisiting(RustNode *node)
 {
     visitChildren(node);
 }
 
 void ContextBuilder::setContextOnNode(RustNode *node, KDevelop::DUContext *context)
 {
     node->setContext(context);
 }
 
 KDevelop::DUContext *ContextBuilder::contextFromNode(RustNode *node)
 {
     return node->getContext();
 }
 
 KDevelop::RangeInRevision ContextBuilder::editorFindRange(RustNode *fromNode, RustNode *toNode)
 {
     RSRange fromRange = node_get_extent(fromNode->data());
     RSRange toRange = node_get_extent(toNode->data());
 
     return RangeInRevision(fromRange.start.line - 1, fromRange.start.column, toRange.end.line - 1, toRange.end.column);
 }
 
 KDevelop::QualifiedIdentifier ContextBuilder::identifierForNode(RustPath *node)
 {
     return QualifiedIdentifier(node->value);
 }
 
 KDevelop::DUContext *ContextBuilder::newContext(const KDevelop::RangeInRevision &range)
 {
     return new RustNormalDUContext(range, currentContext());
 }
 
 KDevelop::TopDUContext *ContextBuilder::newTopContext(const KDevelop::RangeInRevision &range, KDevelop::ParsingEnvironmentFile *file)
 {
     if (!file) {
         file = new ParsingEnvironmentFile(document());
         file->setLanguage(IndexedString("Rust"));
     }
 
     return new RustTopDUContext(document(), range, file);
 }
 
 RSVisitResult visitCallback(RSNode *node, RSNode *parent, void *data)
 {
     ContextBuilder *builder = static_cast<ContextBuilder *>(data);
     RustNode currentNode(node);
     RustNode parentNode(parent);
     return builder->visitNode(&currentNode, &parentNode);
 }
 
 }
diff --git a/duchain/contextbuilder.h b/duchain/contextbuilder.h
index 5c465bf..83955aa 100644
--- a/duchain/contextbuilder.h
+++ b/duchain/contextbuilder.h
@@ -1,42 +1,42 @@
 #ifndef CONTEXTBUILDER_H
 #define CONTEXTBUILDER_H
 
 #include <language/duchain/builders/abstractcontextbuilder.h>
 
 #include "rustnode.h"
 
 namespace Rust
 {
 
 using ContextBuilderBase = KDevelop::AbstractContextBuilder<RustNode, RustPath>;
 
 class ContextBuilder : public ContextBuilderBase
 {
 public:
     ContextBuilder() = default;
     virtual ~ContextBuilder() = default;
 
 protected:
-    KDevelop::RangeInRevision editorFindSpellingRange(RustNode *node, const KDevelop::Identifier &identifier);
+    KDevelop::RangeInRevision editorFindSpellingRange(RustNode *node, const QString &identifier);
 
     template<RSNodeKind Kind>
     KDevelop::DUContext *createContext(RSNode *node, const KDevelop::QualifiedIdentifier& scopeId);
 
     virtual RSVisitResult visitNode(RustNode *node, RustNode *parent) = 0;
     void visitChildren(RustNode *node);
 
     void startVisiting(RustNode *node) override;
     void setContextOnNode(RustNode *node, KDevelop::DUContext *context) override;
     KDevelop::DUContext *contextFromNode(RustNode *node) override;
     KDevelop::RangeInRevision editorFindRange(RustNode *fromNode, RustNode *toNode) override;
     KDevelop::QualifiedIdentifier identifierForNode(RustPath *node) override;
     KDevelop::DUContext *newContext(const KDevelop::RangeInRevision &range) override;
     KDevelop::TopDUContext *newTopContext(const KDevelop::RangeInRevision &range, KDevelop::ParsingEnvironmentFile *file) override;
 
 private:
     friend RSVisitResult visitCallback(RSNode *node, RSNode *parent, void *data);
 };
 
 }
 
 #endif // CONTEXTBUILDER_H
diff --git a/duchain/declarationbuilder.cpp b/duchain/declarationbuilder.cpp
index 009c110..aef6b0e 100644
--- a/duchain/declarationbuilder.cpp
+++ b/duchain/declarationbuilder.cpp
@@ -1,152 +1,152 @@
 #include "declarationbuilder.h"
 
 #include <type_traits>
 
 #include <language/duchain/duchainlock.h>
 
 #include "types/declarationtypes.h"
 #include "nodetraits.h"
 #include "rustdebug.h"
 
 namespace Rust
 {
 
 using namespace KDevelop;
 
 RSVisitResult DeclarationBuilder::visitNode(RustNode *node, RustNode *parent)
 {
     RSNodeKind kind = node_get_kind(node->data());
 
     switch (kind) {
     case StructDecl:
         return buildDeclaration<StructDecl>(node, parent);
     case EnumDecl:
         return buildDeclaration<EnumDecl>(node, parent);
     case FunctionDecl:
         return buildDeclaration<FunctionDecl>(node, parent);
     case ImplDecl:
         return buildDeclaration<ImplDecl>(node, parent);
     case TraitDecl:
         return buildDeclaration<TraitDecl>(node, parent);
     case TypeAliasDecl:
         return buildDeclaration<TypeAliasDecl>(node, parent);
     case EnumVariantDecl:
         return buildDeclaration<EnumVariantDecl>(node, parent);
     case FieldDecl:
         return buildDeclaration<FieldDecl>(node, parent);
     case VarDecl:
         return buildDeclaration<VarDecl>(node, parent);
     default:
         return Recurse;
     }
 }
 
 template<RSNodeKind Kind>
 RSVisitResult DeclarationBuilder::buildDeclaration(RustNode *node, RustNode *parent)
 {
     Q_UNUSED(parent);
     constexpr bool hasContext = NodeTraits::hasContext(Kind);
 
     RustPath name(node);
     RSRange range = node_get_spelling_range(node->data());
     RSRange extent = node_get_extent(node->data());
 
     qCDebug(KDEV_RUST) << "DECLARATION:" << name.value << "; spelling range: ("
                        << range.start.line << ":" << range.start.column << "-"
                        << range.end.line << ":" << range.end.column << "); extent: ("
                        << extent.start.line << ":" << extent.start.column << "-"
                        << extent.end.line << ":" << extent.end.column << ")";
 
     if (hasContext) {
-        createDeclaration<Kind>(node, Identifier(name.value));
+        createDeclaration<Kind>(node, &name);
         openContext(node, NodeTraits::contextType(Kind), &name);
         visitChildren(node);
         closeContext();
         eventuallyAssignInternalContext();
         closeDeclaration();
         return Continue;
     }
-    createDeclaration<Kind>(node, Identifier(name.value));
+    createDeclaration<Kind>(node, &name);
     return Recurse;
 }
 
 template <RSNodeKind Kind>
-Declaration *DeclarationBuilder::createDeclaration(RustNode *node, const Identifier &id)
+Declaration *DeclarationBuilder::createDeclaration(RustNode *node, RustPath *name)
 {
-    auto range = editorFindSpellingRange(node, id);
+    auto range = editorFindSpellingRange(node, name->value);
 
-    Declaration *decl = openDeclaration<typename DeclType<Kind>::Type>(id, range);
+    Declaration *decl = openDeclaration<typename DeclType<Kind>::Type>(Identifier(name->value), range);
     auto type = createType<Kind>(node);
     openType(type);
 
     if (Kind == TypeAliasDecl) {
         decl->setIsTypeAlias(true);
     }
 
     if (NodeTraits::isTypeDeclaration(Kind)) {
         decl->setKind(Declaration::Type);
     }
 
     setDeclData<Kind>(decl);
     setType<Kind>(decl, type.data());
     closeType();
 
     return decl;
 }
 
 template <RSNodeKind Kind, EnableIf<NodeTraits::isTypeDeclaration(Kind)>>
 typename IdType<Kind>::Type::Ptr DeclarationBuilder::createType(RustNode *node)
 {
     Q_UNUSED(node);
     return typename IdType<Kind>::Type::Ptr(new typename IdType<Kind>::Type);
 }
 
 template <RSNodeKind Kind, EnableIf<Kind == FunctionDecl>>
 FunctionType::Ptr DeclarationBuilder::createType(RustNode *node)
 {
     Q_UNUSED(node);
     return FunctionType::Ptr(new FunctionType);
 }
 
 template <RSNodeKind Kind, EnableIf<!NodeTraits::isTypeDeclaration(Kind) && Kind != FunctionDecl>>
 AbstractType::Ptr DeclarationBuilder::createType(RustNode *node)
 {
     Q_UNUSED(node);
     return AbstractType::Ptr(nullptr);
 }
 
 template <RSNodeKind Kind>
 void DeclarationBuilder::setType(Declaration *decl, typename IdType<Kind>::Type *type)
 {
     setType<Kind>(decl, static_cast<IdentifiedType *>(type));
     setType<Kind>(decl, static_cast<AbstractType *>(type));
 }
 
 template <RSNodeKind Kind>
 void DeclarationBuilder::setType(Declaration *decl, IdentifiedType *type)
 {
     type->setDeclaration(decl);
 }
 
 template <RSNodeKind Kind>
 void DeclarationBuilder::setType(Declaration *decl, AbstractType *type)
 {
     decl->setAbstractType(AbstractType::Ptr(type));
 }
 
 template<RSNodeKind Kind, EnableIf<NodeTraits::isTypeDeclaration(Kind)>>
 void DeclarationBuilder::setDeclData(ClassDeclaration *decl)
 {
     if (Kind == StructDecl || Kind == ImplDecl) {
         decl->setClassType(ClassDeclarationData::Struct);
     } else if (Kind == TraitDecl) {
         decl->setClassType(ClassDeclarationData::Trait);
     }
 }
 
 template<RSNodeKind Kind>
 void DeclarationBuilder::setDeclData(Declaration *decl)
 {
 }
 
 }
diff --git a/duchain/declarationbuilder.h b/duchain/declarationbuilder.h
index f0a537b..e7d3b2e 100644
--- a/duchain/declarationbuilder.h
+++ b/duchain/declarationbuilder.h
@@ -1,70 +1,70 @@
 #ifndef DECLARATIONBUILDER_H
 #define DECLARATIONBUILDER_H
 
 #include <type_traits>
 
 #include <language/duchain/builders/abstracttypebuilder.h>
 #include <language/duchain/builders/abstractdeclarationbuilder.h>
 #include <language/duchain/types/alltypes.h>
 
 #include "duchain/types/declarationtypes.h"
 #include "duchain/contextbuilder.h"
 #include "duchain/nodetraits.h"
 #include "duchain/rustnode.h"
 #include "duchain/astredux.h"
 
 namespace Rust
 {
 
 using TypeBuilderBase = KDevelop::AbstractTypeBuilder<RustNode, RustPath, ContextBuilder>;
 using DeclarationBuilderBase = KDevelop::AbstractDeclarationBuilder<RustNode, RustPath, TypeBuilderBase>;
 
 namespace detail { enum class enabler {}; }
 constexpr detail::enabler dummy = {};
 template <bool Condition>
 using EnableIf = typename std::enable_if<Condition, detail::enabler>::type;
 
 class DeclarationBuilder : public DeclarationBuilderBase
 {
 public:
     DeclarationBuilder() = default;
     virtual ~DeclarationBuilder() = default;
 
 protected:
     virtual RSVisitResult visitNode(RustNode *node, RustNode *parent);
 
 private:
     template <RSNodeKind Kind>
     RSVisitResult buildDeclaration(RustNode *node, RustNode *parent);
 
     template <RSNodeKind Kind>
-    KDevelop::Declaration *createDeclaration(RustNode *node, const KDevelop::Identifier &id);
+    KDevelop::Declaration *createDeclaration(RustNode *node, RustPath *names);
 
     template <RSNodeKind Kind, EnableIf<NodeTraits::isTypeDeclaration(Kind)> = dummy>
     typename IdType<Kind>::Type::Ptr createType(RustNode *node);
 
     template <RSNodeKind Kind, EnableIf<Kind == FunctionDecl> = dummy>
     KDevelop::FunctionType::Ptr createType(RustNode *node);
 
     template <RSNodeKind Kind, EnableIf<!NodeTraits::isTypeDeclaration(Kind) && Kind != FunctionDecl> = dummy>
     KDevelop::AbstractType::Ptr createType(RustNode *node);
 
     template <RSNodeKind Kind>
     void setDeclData(KDevelop::Declaration *decl);
 
     template <RSNodeKind Kind, EnableIf<NodeTraits::isTypeDeclaration(Kind)> = dummy>
     void setDeclData(KDevelop::ClassDeclaration *decl);
 
     template <RSNodeKind Kind>
     void setType(KDevelop::Declaration *decl, typename IdType<Kind>::Type *type);
 
     template <RSNodeKind Kind>
     void setType(KDevelop::Declaration *decl, KDevelop::IdentifiedType *type);
 
     template <RSNodeKind Kind>
     void setType(KDevelop::Declaration *decl, KDevelop::AbstractType *type);
 };
 
 }
 
 #endif // DECLARATIONBUILDER_H