diff --git a/duchain/declarationbuilder.cpp b/duchain/declarationbuilder.cpp
index fcb67d7..8d057f8 100644
--- a/duchain/declarationbuilder.cpp
+++ b/duchain/declarationbuilder.cpp
@@ -1,141 +1,160 @@
 #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 Module:
         return buildDeclaration<Module>(node, parent);
     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 ContextBuilder::visitNode(node, parent);
     }
 }
 
 template<RSNodeKind Kind>
 RSVisitResult DeclarationBuilder::buildDeclaration(RustNode *node, RustNode *parent)
 {
     Q_UNUSED(parent);
     constexpr bool hasContext = NodeTraits::hasContext(Kind);
 
     RustPath name(node);
 
     createDeclaration<Kind>(node, &name, hasContext);
     RSVisitResult ret = buildContext<Kind>(node, parent);
     if (hasContext) eventuallyAssignInternalContext();
     closeDeclaration();
     return ret;
 }
 
 template <RSNodeKind Kind>
 Declaration *DeclarationBuilder::createDeclaration(RustNode *node, RustPath *name, bool hasContext)
 {
     auto range = editorFindSpellingRange(node, name->value);
 
     Declaration *decl = openDeclaration<typename DeclType<Kind>::Type>(Identifier(name->value), range,
                                                                        hasContext ? DeclarationIsDefinition : NoFlags);
     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>
+template<RSNodeKind Kind, EnableIf<Kind == Module>>
+void DeclarationBuilder::setDeclData(Declaration *decl)
+{
+    decl->setKind(Declaration::Namespace);
+}
+
+template<RSNodeKind Kind, EnableIf<Kind == VarDecl>>
+void DeclarationBuilder::setDeclData(Declaration *decl)
+{
+    decl->setKind(Declaration::Instance);
+}
+
+template<RSNodeKind Kind, EnableIf<Kind == TypeAliasDecl>>
+void DeclarationBuilder::setDeclData(AliasDeclaration *decl)
+{
+    decl->setKind(Declaration::Alias);
+}
+
+template<RSNodeKind Kind, EnableIf<Kind != VarDecl && Kind != Module>>
 void DeclarationBuilder::setDeclData(Declaration *decl)
 {
+    Q_UNUSED(decl);
 }
 
 }
diff --git a/duchain/declarationbuilder.h b/duchain/declarationbuilder.h
index 8961c1a..4347562 100644
--- a/duchain/declarationbuilder.h
+++ b/duchain/declarationbuilder.h
@@ -1,70 +1,79 @@
 #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;
     ~DeclarationBuilder() override = default;
 
 protected:
     RSVisitResult visitNode(RustNode *node, RustNode *parent) override;
 
 private:
     template <RSNodeKind Kind>
     RSVisitResult buildDeclaration(RustNode *node, RustNode *parent);
 
     template <RSNodeKind Kind>
     KDevelop::Declaration *createDeclaration(RustNode *node, RustPath *name, bool hasContext);
 
     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>
+    template <RSNodeKind Kind, EnableIf<Kind != VarDecl && Kind != Module> = dummy>
+    void setDeclData(KDevelop::Declaration *decl);
+
+    template<RSNodeKind Kind, EnableIf<Kind == VarDecl> = dummy>
     void setDeclData(KDevelop::Declaration *decl);
 
+    template<RSNodeKind Kind, EnableIf<Kind == Module> = dummy>
+    void setDeclData(KDevelop::Declaration *decl);
+
+    template<RSNodeKind Kind, EnableIf<Kind == TypeAliasDecl> = dummy>
+    void setDeclData(KDevelop::AliasDeclaration *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
diff --git a/duchain/nodetraits.h b/duchain/nodetraits.h
index 1927c05..3710237 100644
--- a/duchain/nodetraits.h
+++ b/duchain/nodetraits.h
@@ -1,51 +1,50 @@
 #ifndef NODETRAITS_H
 #define NODETRAITS_H
 
 #include <language/duchain/ducontext.h>
 
 #include "astredux.h"
 
 namespace Rust
 {
 
 namespace NodeTraits
 {
 
 constexpr bool hasContext(RSNodeKind kind)
 {
     return kind == Crate || kind == Module || kind == StructDecl || kind == EnumDecl
             || kind == TraitDecl || kind == ImplDecl || kind == FunctionDecl || kind == Block;
 }
 
 constexpr KDevelop::DUContext::ContextType contextType(RSNodeKind kind)
 {
     using namespace KDevelop;
     return kind == Crate        ? DUContext::Global
         :  kind == Module       ? DUContext::Namespace
         :  kind == StructDecl   ? DUContext::Class
         :  kind == EnumDecl     ? DUContext::Enum
         :  kind == TraitDecl    ? DUContext::Class
         :  kind == ImplDecl     ? DUContext::Class
         :  kind == FunctionDecl ? DUContext::Function
         :  kind == Block        ? DUContext::Other
         : static_cast<DUContext::ContextType>(-1);
 }
 
 constexpr bool isKDevDeclaration(RSNodeKind kind)
 {
-    return kind == EnumDecl || kind == TypeAliasDecl || kind == EnumVariantDecl
+    return kind == EnumDecl || kind == EnumVariantDecl
             || kind == ParmDecl || kind == VarDecl || kind == Module;
 }
 
 constexpr bool isTypeDeclaration(RSNodeKind kind)
 {
     return  kind == EnumDecl || kind == EnumVariantDecl
-            || kind == TypeAliasDecl || kind == StructDecl
-            || kind == ImplDecl || kind == TraitDecl;
+            || kind == StructDecl || kind == ImplDecl || kind == TraitDecl;
 }
 
 }
 
 }
 
 #endif // NODETRAITS_H
diff --git a/duchain/types/declarationtypes.h b/duchain/types/declarationtypes.h
index 6502432..8e74597 100644
--- a/duchain/types/declarationtypes.h
+++ b/duchain/types/declarationtypes.h
@@ -1,81 +1,88 @@
 #ifndef DECLARATIONTYPES_H
 #define DECLARATIONTYPES_H
 
 #include <type_traits>
 
 #include <language/duchain/types/abstracttype.h>
 #include <language/duchain/types/alltypes.h>
 #include <language/duchain/classdeclaration.h>
 #include <language/duchain/functiondeclaration.h>
 #include <language/duchain/classmemberdeclaration.h>
+#include <language/duchain/aliasdeclaration.h>
 
 #include "duchain/astredux.h"
 #include "duchain/nodetraits.h"
 
 namespace Rust
 {
 
 template <RSNodeKind Kind, class Enable = void>
 struct IdType;
 
 template <RSNodeKind Kind>
 struct IdType<Kind, typename std::enable_if<Kind == StructDecl || Kind == TraitDecl || Kind == ImplDecl>::type>
 {
     typedef KDevelop::StructureType Type;
 };
 
 template <RSNodeKind Kind>
 struct IdType<Kind, typename std::enable_if<Kind == TypeAliasDecl>::type>
 {
     typedef KDevelop::TypeAliasType Type;
 };
 
 template <RSNodeKind Kind>
 struct IdType<Kind, typename std::enable_if<Kind == EnumDecl>::type>
 {
     typedef KDevelop::EnumerationType Type;
 };
 
 template <RSNodeKind Kind>
 struct IdType<Kind, typename std::enable_if<Kind == EnumVariantDecl>::type>
 {
     typedef KDevelop::EnumeratorType Type;
 };
 
 template <RSNodeKind Kind, class Enable = void>
 struct DeclType;
 
 template <RSNodeKind Kind>
 struct DeclType<Kind, typename std::enable_if<NodeTraits::isKDevDeclaration(Kind)>::type>
 {
     typedef KDevelop::Declaration Type;
 };
 
 template <RSNodeKind Kind>
 struct DeclType<Kind, typename std::enable_if<Kind == StructDecl || Kind == TraitDecl || Kind == ImplDecl>::type>
 {
     typedef KDevelop::ClassDeclaration Type;
 };
 
+template <RSNodeKind Kind>
+struct DeclType<Kind, typename std::enable_if<Kind == TypeAliasDecl>::type>
+{
+    typedef KDevelop::AliasDeclaration Type;
+};
+
 // FIXME: specialize
 //template <RSNodeKind Kind>
 //struct DeclType<Kind, typename std::enable_if<Kind == FunctionDecl>::type>
 //{
 //    typedef KDevelop::ClassFunctionDeclaration Type;
 //};
 
 template <RSNodeKind Kind>
 struct DeclType<Kind, typename std::enable_if<Kind == FunctionDecl>::type>
 {
     typedef KDevelop::FunctionDeclaration Type;
 };
 
 template <RSNodeKind Kind>
 struct DeclType<Kind, typename std::enable_if<Kind == FieldDecl>::type>
 {
     typedef KDevelop::ClassMemberDeclaration Type;
 };
 
 }
 
 #endif // DECLARATIONTYPES_H