diff --git a/lib/jsduck/aggregator.rb b/lib/jsduck/aggregator.rb
index 5ba8da138a674ba1c43df61be62c372cd640b4c1..d343190db9cdc4d2364d7fbb30ad34b49169f52d 100644
--- a/lib/jsduck/aggregator.rb
+++ b/lib/jsduck/aggregator.rb
@@ -93,7 +93,7 @@ module JsDuck
         old[tag] = old[tag] + new[tag]
       end
       # Merge hashes of arrays
-      [:xtypes, :meta].each do |tag|
+      [:aliases, :meta].each do |tag|
         new[tag].each_pair do |key, contents|
           old[tag][key] = (old[tag][key] || []) + contents
         end
diff --git a/lib/jsduck/merger.rb b/lib/jsduck/merger.rb
index 031dc001992e144b00355e3b3579b7cd540ffcf2..b7cae502764bb9ecf2d9c6d5e6ab92a01fff9b7a 100644
--- a/lib/jsduck/merger.rb
+++ b/lib/jsduck/merger.rb
@@ -123,7 +123,7 @@ module JsDuck
         :extends => detect_extends(doc_map, code),
         :mixins => detect_list(:mixins, doc_map, code),
         :alternateClassNames => detect_list(:alternateClassNames, doc_map, code),
-        :xtypes => detect_xtypes(doc_map, code),
+        :aliases => detect_aliases(doc_map, code),
         :singleton => detect_singleton(doc_map, code),
         :requires => detect_list(:requires, doc_map, code),
         :uses => detect_list(:uses, doc_map, code),
@@ -330,28 +330,28 @@ module JsDuck
       end
     end
 
-    def detect_xtypes(doc_map, code)
+    def detect_aliases(doc_map, code)
       if doc_map[:xtype]
         {"widget" => doc_map[:xtype].map {|tag| tag[:name] } }
       elsif code[:xtype] || code[:alias]
-        xtypes = {}
+        aliases = {}
         (code[:xtype] || []).each do |a|
-          if xtypes["widget"]
-            xtypes["widget"] << a
+          if aliases["widget"]
+            aliases["widget"] << a
           else
-            xtypes["widget"] = [a]
+            aliases["widget"] = [a]
           end
         end
         (code[:alias] || []).each do |a|
           if a =~ /^([\w.]+)\.(\w+)$/
-            if xtypes[$1]
-              xtypes[$1] << $2
+            if aliases[$1]
+              aliases[$1] << $2
             else
-              xtypes[$1] = [$2]
+              aliases[$1] = [$2]
             end
           end
         end
-        xtypes
+        aliases
       else
         {}
       end
diff --git a/lib/jsduck/search_data.rb b/lib/jsduck/search_data.rb
index eebe744ee9b8cd8dcc187c0714f4a0eb9785701a..d8409503854656752f7632e55f0ebf0e952a928d 100644
--- a/lib/jsduck/search_data.rb
+++ b/lib/jsduck/search_data.rb
@@ -30,7 +30,7 @@ module JsDuck
         :cls => cls.full_name,
         :member => cls.short_name,
         :type => :class,
-        :xtypes => cls[:xtypes]
+        :aliases => cls[:aliases]
       }
     end
 
diff --git a/spec/aggregator_aliases_spec.rb b/spec/aggregator_aliases_spec.rb
new file mode 100644
index 0000000000000000000000000000000000000000..b6c3c87bc0134b057c8034fc0fcc92fbf357f7cf
--- /dev/null
+++ b/spec/aggregator_aliases_spec.rb
@@ -0,0 +1,173 @@
+require "jsduck/aggregator"
+require "jsduck/source_file"
+
+describe JsDuck::Aggregator do
+
+  def parse(string)
+    agr = JsDuck::Aggregator.new
+    agr.aggregate(JsDuck::SourceFile.new(string))
+    agr.result
+  end
+
+  shared_examples_for "single alias" do
+    it "detects alias" do
+      @doc[:aliases].should == {"widget" => ["foo"]}
+    end
+  end
+
+  shared_examples_for "multiple aliases" do
+    it "collects all aliases together" do
+      @doc[:aliases].should == {"widget" => ["foo", "bar"]}
+    end
+  end
+
+  describe "class with @xtype" do
+    before do
+      @doc = parse(<<-EOS)[0]
+        /**
+         * @class MyClass
+         * @xtype foo
+         */
+      EOS
+    end
+    it_should_behave_like "single alias"
+  end
+
+  describe "@xtype after @constructor" do
+    before do
+      @doc = parse(<<-EOS)[0]
+        /**
+         * @class MyClass
+         * Comment here.
+         * @constructor
+         * This constructs the class
+         * @xtype foo
+         */
+      EOS
+    end
+    it_should_behave_like "single alias"
+  end
+
+  describe "class with multiple @xtypes" do
+    before do
+      @doc = parse(<<-EOS)[0]
+        /**
+         * @class MyClass
+         * @xtype foo
+         * @xtype bar
+         * Some documentation.
+         */
+      EOS
+    end
+    it_should_behave_like "multiple aliases"
+  end
+
+  describe "Ext.define() with simple alias" do
+    before do
+      @doc = parse(<<-EOS)[0]
+        /** */
+        Ext.define('MyClass', {
+          alias: 'widget.foo'
+        });
+      EOS
+    end
+    it_should_behave_like "single alias"
+  end
+
+  describe "Ext.define() with @xtype overriding alias" do
+    before do
+      @doc = parse(<<-EOS)[0]
+        /**
+         * @xtype foo
+         */
+        Ext.define('MyClass', {
+          alias: 'widget.xxx'
+        });
+      EOS
+    end
+    it_should_behave_like "single alias"
+  end
+
+  describe "Ext.define() with array of aliases" do
+    before do
+      @doc = parse(<<-EOS)[0]
+        /** */
+        Ext.define('MyClass', {
+          alias: ['widget.foo', 'widget.bar']
+        });
+      EOS
+    end
+    it_should_behave_like "multiple aliases"
+  end
+
+  describe "Ext.define() with different kinds of aliases" do
+    before do
+      @doc = parse(<<-EOS)[0]
+        /** */
+        Ext.define('MyClass', {
+          alias: ['store.json', 'store.ajax', 'component.myclass']
+        });
+      EOS
+    end
+    it "collects all aliases together" do
+      @doc[:aliases].should == {"store" => ["json", "ajax"], "component" => ["myclass"]}
+    end
+  end
+
+  describe "Ext.define() with xtype property" do
+    before do
+      @doc = parse(<<-EOS)[0]
+        /** */
+        Ext.define('MyClass', {
+          xtype: 'foo'
+        });
+      EOS
+    end
+    it_should_behave_like "single alias"
+  end
+
+  describe "Ext.define() with array xtype property" do
+    before do
+      @doc = parse(<<-EOS)[0]
+        /** */
+        Ext.define('MyClass', {
+          xtype: ['foo', 'bar']
+        });
+      EOS
+    end
+    it_should_behave_like "multiple aliases"
+  end
+
+  describe "Ext.define() with both xtype and alias" do
+    before do
+      @doc = parse(<<-EOS)[0]
+        /** */
+        Ext.define('MyClass', {
+          xtype: 'foo',
+          alias: 'widget.bar'
+        });
+      EOS
+    end
+    it_should_behave_like "multiple aliases"
+  end
+
+  describe "one class many times" do
+    before do
+      @doc = parse(<<-EOS)[0]
+        /**
+         * @class Foo
+         */
+        /**
+         * @class Foo
+         * @xtype foo
+         */
+        /**
+         * @class Foo
+         * @xtype bar
+         */
+      EOS
+    end
+    it_should_behave_like "multiple aliases"
+  end
+
+end
diff --git a/template/app/controller/Search.js b/template/app/controller/Search.js
index 351f519b6fe9eccb97a1bd9d5ec3b2adc54cb4fe..f4869b29adbd54937f757f7f14124d74d3f310eb 100644
--- a/template/app/controller/Search.js
+++ b/template/app/controller/Search.js
@@ -167,13 +167,13 @@ Ext.define('Docs.controller.Search', {
             // Otherwise search from just the member name (e.g. "focus" or "Component")
             var name = hasDot ? r.cls + (r.type === "class" ? "" : "." + r.member) : r.member;
 
-            if (r.xtypes && this.matchXType(r.xtypes, reFull)) {
+            if (r.aliases && this.matchAlias(r.aliases, reFull)) {
                 results[xFull].push(r);
             }
             else if (reFull.test(name)) {
                 results[r.type === "class" ? clsFull : mFull].push(r);
             }
-            else if (r.xtypes && this.matchXType(r.xtypes, reBeg)) {
+            else if (r.aliases && this.matchAlias(r.aliases, reBeg)) {
                 results[xBeg].push(r);
             }
             else if (reBeg.test(name)) {
@@ -187,11 +187,11 @@ Ext.define('Docs.controller.Search', {
         return Ext.Array.flatten(results);
     },
 
-    // true if xtype, ptype, ftype, etc matches regex
-    matchXType: function(xtypes, regex) {
-        for (var key in xtypes) {
-            if (xtypes.hasOwnProperty(key)) {
-                if (Ext.Array.some(xtypes[key], function(x) {return regex.test(x);})) {
+    // true if alias matches regex
+    matchAlias: function(aliases, regex) {
+        for (var key in aliases) {
+            if (aliases.hasOwnProperty(key)) {
+                if (Ext.Array.some(aliases[key], function(x) {return regex.test(x);})) {
                     return true;
                 }
             }
diff --git a/template/app/store/Search.js b/template/app/store/Search.js
index 88c253558e9170774fd0d1654feed17295fb8f5f..f98950a02a088fd712279eefdf1865bba60af80e 100644
--- a/template/app/store/Search.js
+++ b/template/app/store/Search.js
@@ -4,7 +4,7 @@
 Ext.define('Docs.store.Search', {
     extend: 'Ext.data.Store',
 
-    fields: ['cls', 'member', 'type', 'xtypes', 'id'],
+    fields: ['cls', 'member', 'type', 'aliases', 'id'],
     proxy: {
         type: 'memory',
         reader: {
diff --git a/template/app/view/cls/Header.js b/template/app/view/cls/Header.js
index 61b85bd634f6d8b3f363180333b54e6dbe9d3e8a..2cbc9911452bba8cc7dddad08971eb7b99f64e69 100644
--- a/template/app/view/cls/Header.js
+++ b/template/app/view/cls/Header.js
@@ -19,7 +19,7 @@ Ext.define('Docs.view.cls.Header', {
                 '<a href="#" class="class-source-link">{name}',
                   '<span class="class-source-tip">View source...</span>',
                 '</a>',
-                '{[this.renderXTypes(values.xtypes)]}',
+                '{[this.renderAliases(values.aliases)]}',
             '</h1>',
             Docs.showPrintButton ? '<a class="print" href="?print=/api/{name}" target="_blank">Print</a>' : '',
             {
@@ -34,14 +34,14 @@ Ext.define('Docs.view.cls.Header', {
                         return "class";
                     }
                 },
-                renderXTypes: function(xtypes) {
+                renderAliases: function(aliases) {
                     var titles = {
                         widget: "xtype",
                         plugin: "ptype",
                         feature: "ftype"
                     };
                     var r = [];
-                    xtypes && Ext.Object.each(xtypes, function(ns, types) {
+                    aliases && Ext.Object.each(aliases, function(ns, types) {
                         r.push((titles[ns] || ns) + ": " + types.join(", "));
                     });