diff --git a/src/LiveDevelopment/LiveDevelopment.js b/src/LiveDevelopment/LiveDevelopment.js
index 48c9cc7ec92..94495bc8c0b 100644
--- a/src/LiveDevelopment/LiveDevelopment.js
+++ b/src/LiveDevelopment/LiveDevelopment.js
@@ -245,10 +245,11 @@ define(function LiveDevelopment(require, exports, module) {
      * @param {Document} document
      */
     function _classForDocument(doc) {
-        switch (doc.getLanguage().getId()) {
-        case "css":
+        var language = doc.getLanguage();
+        if (language.isInstanceOfLanguage("css")) {
             return CSSDocument;
-        case "javascript":
+        }
+        if (language.isInstanceOfLanguage("javascript")) {
             return exports.config.experimental ? JSDocument : null;
         }
 
diff --git a/src/editor/CSSInlineEditor.js b/src/editor/CSSInlineEditor.js
index 01b2dca766d..c196f3581e9 100644
--- a/src/editor/CSSInlineEditor.js
+++ b/src/editor/CSSInlineEditor.js
@@ -90,7 +90,7 @@ define(function (require, exports, module) {
      */
     function htmlToCSSProvider(hostEditor, pos) {
         // Only provide a CSS editor when cursor is in HTML content
-        if (hostEditor.getLanguageForSelection().getId() !== "html") {
+        if (!hostEditor.getLanguageForSelection().isInstanceOfLanguage("html")) {
             return null;
         }
         
diff --git a/src/editor/CodeHintManager.js b/src/editor/CodeHintManager.js
index 9649f5a1b6e..fdf3a22c3fa 100644
--- a/src/editor/CodeHintManager.js
+++ b/src/editor/CodeHintManager.js
@@ -285,11 +285,11 @@ define(function (require, exports, module) {
      *  Return the array of hint providers for the given language id.
      *  This gets called (potentially) on every keypress. So, it should be fast.
      *
-     * @param {!string} languageId
+     * @param {!Language} language
      * @return {?Array.<{provider: Object, priority: number}>}
      */
-    function _getProvidersForLanguageId(languageId) {
-        return hintProviders[languageId] || hintProviders.all;
+    function _getProvidersForLanguage(language) {
+        return language.findEntryInObject(hintProviders) || hintProviders.all;
     }
 
     /**
@@ -375,7 +375,7 @@ define(function (require, exports, module) {
     function _beginSession(editor) {
         // Find a suitable provider, if any
         var language = editor.getLanguageForSelection(),
-            enabledProviders = _getProvidersForLanguageId(language.getId());
+            enabledProviders = _getProvidersForLanguage(language);
         
         enabledProviders.some(function (item, index) {
             if (item.provider.hasHints(editor, lastChar)) {
diff --git a/src/extensions/default/JSLint/main.js b/src/extensions/default/JSLint/main.js
index 9d1c92d238a..741a6fc2bd9 100644
--- a/src/extensions/default/JSLint/main.js
+++ b/src/extensions/default/JSLint/main.js
@@ -107,7 +107,7 @@ define(function (require, exports, module) {
         
         var language = currentDoc ? LanguageManager.getLanguageForPath(currentDoc.file.fullPath) : "";
         
-        if (_enabled && language && language.getId() === "javascript") {
+        if (_enabled && language && language.isInstanceOfLanguage("javascript")) {
             perfTimerLint = PerfUtils.markStart("JSLint linting:\t" + (!currentDoc || currentDoc.file.fullPath));
             var text = currentDoc.getText();
             
diff --git a/src/extensions/default/JavaScriptCodeHints/HintUtils.js b/src/extensions/default/JavaScriptCodeHints/HintUtils.js
index 7b8fcc0b961..df0b14d476b 100644
--- a/src/extensions/default/JavaScriptCodeHints/HintUtils.js
+++ b/src/extensions/default/JavaScriptCodeHints/HintUtils.js
@@ -170,8 +170,8 @@ define(function (require, exports, module) {
         });
     }
 
-    function isSupportedLanguage(languageId) {
-        return SUPPORTED_LANGUAGES.indexOf(languageId) !== -1;
+    function isSupportedLanguage(language) {
+        return language.isInstanceOfLanguageInArray(SUPPORTED_LANGUAGES);
     }
     var KEYWORD_NAMES   = [
         "break", "case", "catch", "continue", "debugger", "default", "delete",
diff --git a/src/extensions/default/JavaScriptCodeHints/ScopeManager.js b/src/extensions/default/JavaScriptCodeHints/ScopeManager.js
index 5de17df2939..c5571cd50a3 100644
--- a/src/extensions/default/JavaScriptCodeHints/ScopeManager.js
+++ b/src/extensions/default/JavaScriptCodeHints/ScopeManager.js
@@ -200,8 +200,8 @@ define(function (require, exports, module) {
                     if (fileCallback && entry.isFile) {
 
                         if (file.indexOf(".") > 0) { // ignore .dotfiles
-                            var languageID = LanguageManager.getLanguageForPath(path).getId();
-                            if (languageID === HintUtils.LANGUAGE_ID) {
+                            var language = LanguageManager.getLanguageForPath(path);
+                            if (language.isInstanceOfLanguage(HintUtils.LANGUAGE_ID)) {
                                 fileCallback(path);
                             }
                         }
diff --git a/src/extensions/default/JavaScriptCodeHints/Session.js b/src/extensions/default/JavaScriptCodeHints/Session.js
index e93e023b40d..967dd1b54d4 100644
--- a/src/extensions/default/JavaScriptCodeHints/Session.js
+++ b/src/extensions/default/JavaScriptCodeHints/Session.js
@@ -504,7 +504,7 @@ define(function (require, exports, module) {
      * @return {string} - the "javascript" text that can be sent to Tern.
      */
     Session.prototype.getJavascriptText = function () {
-        if (LanguageManager.getLanguageForPath(this.editor.document.file.fullPath).getId() === "html") {
+        if (this.editor.document.getLanguage().isInstanceOfLanguage("html")) {
             // HTML file - need to send back only the bodies of the
             // <script> tags
             var text = "",
diff --git a/src/extensions/default/JavaScriptCodeHints/main.js b/src/extensions/default/JavaScriptCodeHints/main.js
index 5a74b314b28..3d73fc8b251 100644
--- a/src/extensions/default/JavaScriptCodeHints/main.js
+++ b/src/extensions/default/JavaScriptCodeHints/main.js
@@ -239,13 +239,12 @@ define(function (require, exports, module) {
     /**
      * @return {boolean} - true if the document is a html file
      */
-    function isHTMLFile(document) {
-        var languageID = LanguageManager.getLanguageForPath(document.file.fullPath).getId();
-        return languageID === "html";
+    function isHTMLFile(doc) {
+        return doc.getLanguage().isInstanceOfLanguage("html");
     }
     
     function isInlineScript(editor) {
-        return editor.getModeForSelection() === "javascript";
+        return editor.getLanguageForSelection().isInstanceOfLanguage("javascript");
     }
 
     /**
@@ -470,7 +469,7 @@ define(function (require, exports, module) {
             cachedHints = null;
             cachedType = null;
 
-            if (editor && HintUtils.isSupportedLanguage(LanguageManager.getLanguageForPath(editor.document.file.fullPath).getId())) {
+            if (editor && HintUtils.isSupportedLanguage(LanguageManager.getLanguageForPath(editor.document.file.fullPath))) {
                 initializeSession(editor, true);
             } else {
                 session = null;
diff --git a/src/extensions/default/WebPlatformDocs/main.js b/src/extensions/default/WebPlatformDocs/main.js
index d0fef7332c1..a1a25377f10 100644
--- a/src/extensions/default/WebPlatformDocs/main.js
+++ b/src/extensions/default/WebPlatformDocs/main.js
@@ -85,7 +85,7 @@ define(function (require, exports, module) {
      */
     function inlineProvider(hostEditor, pos) {
         // Only provide docs when cursor is in CSS content
-        if (hostEditor.getLanguageForSelection().getId() !== "css") {
+        if (!hostEditor.getLanguageForSelection().isInstanceOfLanguage("css")) {
             return null;
         }
         
diff --git a/src/language/LanguageManager.js b/src/language/LanguageManager.js
index 8af2607e9da..2c35c65479d 100644
--- a/src/language/LanguageManager.js
+++ b/src/language/LanguageManager.js
@@ -21,7 +21,6 @@
  * 
  */
 
-
 /*jslint vars: true, plusplus: true, devel: true, nomen: true, indent: 4, maxerr: 50 */
 /*global define, $, CodeMirror, PathUtils */
 
@@ -95,6 +94,11 @@
  *
  * If a mode is not shipped with our CodeMirror distribution, you need to first load it yourself.
  * If the mode is part of our CodeMirror distribution, it gets loaded automatically.
+ *
+ * To compare languages, use the following methods:
+ * - isLanguage (if this language should be the same as the passed one)
+ * - isBasedOnLanguage (if this language should be a child of the passed one)
+ * - isInstanceOfLanguage (if this language should be the passed one or a child of it)
  */
 define(function (require, exports, module) {
     "use strict";
@@ -162,8 +166,9 @@ define(function (require, exports, module) {
      * @param {!Language} language The language to associate with the mode
      */
     function _setLanguageForMode(mode, language) {
-        if (_modeToLanguageMap[mode]) {
-            console.warn("CodeMirror mode \"" + mode + "\" is already used by language " + _modeToLanguageMap[mode]._name + ", won't register for " + language._name);
+        var mappedLanguage = _modeToLanguageMap[mode];
+        if (mappedLanguage && !language.isBasedOnLanguage(mappedLanguage)) {
+            console.warn("CodeMirror mode \"" + mode + "\" is already used by language " + mappedLanguage.getName() + ", won't register for " + language.getName());
             return;
         }
 
@@ -292,6 +297,9 @@ define(function (require, exports, module) {
     /** @type {string} Human-readable name of this language */
     Language.prototype._name = null;
     
+    /** @type {?Language} Parent language */
+    Language.prototype._parent = null;
+    
     /** @type {string} CodeMirror mode for this language */
     Language.prototype._mode = null;
     
@@ -304,12 +312,12 @@ define(function (require, exports, module) {
     /** @type {Array.<string>} Line comment syntax */
     Language.prototype._lineCommentSyntax = null;
     
-    /** @type {Object.<string,Language>} Which language to use for what CodeMirror mode */
-    Language.prototype._modeToLanguageMap = null;
-    
     /** @type {{ prefix: string, suffix: string }} Block comment syntax */
     Language.prototype._blockCommentSyntax = null;
     
+    /** @type {Object.<string,Language>} Which language to use for what CodeMirror mode */
+    Language.prototype._modeToLanguageMap = null;
+    
     /**
      * Returns the identifier for this language.
      * @return {string} The identifier
@@ -346,6 +354,95 @@ define(function (require, exports, module) {
         return this._name;
     };
     
+    /**
+     * Set the language this language inherits from
+     * @param {string|Language} parent The parent language or its ID
+     * @return {boolean} Whether parent was valid and set or not
+     */
+    Language.prototype._setParent = function (parent) {
+        if (!(parent instanceof Language)) {
+            parent = getLanguage(parent);
+            if (!(parent instanceof Language)) {
+                console.error("Parent language must be an instance of Language or a valid language ID");
+                return false;
+            }
+        }
+        this._parent = parent;
+
+        return true;
+    };
+
+    /**
+     * Determines whether the language is this language
+     * @param {Language|string} The language (or its ID) to test
+     * @return {boolean} True if this language has the same ID as language, false otherwise
+     **/
+    Language.prototype.isLanguage = function (language) {
+        if (language.getId) {
+            language = language.getId();
+        }
+        
+        return this.getId() === language;
+    };
+
+    /**
+     * Determines whether the language is this language's parent, or the parent's parent, etc.
+     * @param {Language|string} The language (or its ID) to test
+     * @return {boolean} True if this language is a child of language, false otherwise
+     **/
+    Language.prototype.isBasedOnLanguage = function (language) {
+        if (!this._parent) {
+            return false;
+        }
+        return this._parent.isInstanceOfLanguage(language);
+    };
+
+    /**
+     * Determines whether the language is this language or one of its ancestors
+     * @param {Language|string} The language (or its ID) to test
+     * @return {boolean} True if this language is an instance of language, false otherwise
+     **/
+    Language.prototype.isInstanceOfLanguage = function (language) {
+        if (language.getId) {
+            language = language.getId();
+        }
+        
+        return this.isLanguage(language) || this.isBasedOnLanguage(language);
+    };
+    
+    /**
+     * Determines whether one of the languages is this language or one of its ancestors
+     * @param {Array.<Language|string>} The languages (or their IDs) to test
+     * @return {boolean} True if this language is an instance of one of languages, false otherwise
+     **/
+    Language.prototype.isInstanceOfLanguageInArray = function (languages) {
+        var i;
+        for (i = 0; i < languages.length; i++) {
+            if (this.isInstanceOfLanguage(languages[i])) {
+                return true;
+            }
+        }
+        return false;
+    };
+    
+    /**
+     * Uses the ID of this language and its ancestors as a key to an entry in the object (first match wins)
+     * @param {Object.<string, {*}>} A dictionary with language IDs as keys
+     * @return {*} The object's entry with the key closest to this language's ID
+     **/
+    Language.prototype.findEntryInObject = function (object) {
+        var entry,
+            language = this;
+        
+        while (language) {
+            entry = object[language.getId()];
+            if (entry) {
+                return entry;
+            }
+            language = language._parent;
+        }
+    };
+    
     /**
      * Sets the human-readable name of this language or prints an error to the console.
      * @param {!string} name Human-readable name of the language, as it's commonly referred to (i.e. "C++")
@@ -365,7 +462,7 @@ define(function (require, exports, module) {
      * @return {string} The mode
      */
     Language.prototype.getMode = function () {
-        return this._mode;
+        return this._mode || (this._parent && this._parent.getMode());
     };
     
     /**
@@ -379,6 +476,7 @@ define(function (require, exports, module) {
     Language.prototype._loadAndSetMode = function (mode) {
         var result      = new $.Deferred(),
             self        = this,
+            definesOwnMode,
             mimeMode; // Mode can be an array specifying a mode plus a MIME mode defined by that mode ["clike", "text/x-c++src"]
         
         if (Array.isArray(mode)) {
@@ -390,14 +488,15 @@ define(function (require, exports, module) {
             mode = mode[0];
         }
         
-        // mode must not be empty. Use "null" (the string "null") mode for plain text
-        if (!_validateNonEmptyString(mode, "mode", result)) {
-            result.reject();
+        definesOwnMode = !this._parent || mode;
+        
+        // mode must not be empty for root languages. Use "null" (the string "null") mode for plain text
+        if (definesOwnMode && !_validateNonEmptyString(mode, "mode", result)) {
             return result.promise();
         }
         
         var finish = function () {
-            if (!CodeMirror.modes[mode]) {
+            if (definesOwnMode && !CodeMirror.modes[mode]) {
                 result.reject("CodeMirror mode \"" + mode + "\" is not loaded");
                 return;
             }
@@ -417,15 +516,17 @@ define(function (require, exports, module) {
                 }
             }
             
-            // This mode is now only about what to tell CodeMirror
-            // The base mode was only necessary to load the proper mode file
-            self._mode = mimeMode || mode;
-            self._wasModified();
+            if (definesOwnMode) {
+                // This mode is now only about what to tell CodeMirror
+                // The base mode was only necessary to load the proper mode file
+                self._mode = mimeMode || mode;
+                self._wasModified();
+            }
             
             result.resolve(self);
         };
         
-        if (CodeMirror.modes[mode]) {
+        if (!definesOwnMode || CodeMirror.modes[mode]) {
             finish();
         } else {
             require(["thirdparty/CodeMirror2/mode/" + mode + "/" + mode], finish);
@@ -470,10 +571,14 @@ define(function (require, exports, module) {
             this._fileExtensions.push(extension);
             
             var language = _fileExtensionToLanguageMap[extension];
-            if (language) {
+            if (language && !this.isBasedOnLanguage(language)) {
                 console.warn("Cannot register file extension \"" + extension + "\" for " + this._name + ", it already belongs to " + language._name);
             } else {
                 _fileExtensionToLanguageMap[extension] = this;
+                // Must be an ancestor
+                if (language) {
+                    language._removeFileExtension(extension);
+                }
             }
             
             this._wasModified();
@@ -493,23 +598,58 @@ define(function (require, exports, module) {
             this._fileNames.push(name);
             
             var language = _fileNameToLanguageMap[name];
-            if (language) {
+            if (language && !this.isBasedOnLanguage(language)) {
                 console.warn("Cannot register file name \"" + name + "\" for " + this._name + ", it already belongs to " + language._name);
             } else {
                 _fileNameToLanguageMap[name] = this;
+                // Must be an ancestor
+                if (language) {
+                    language._removeFileName(name);
+                }
             }
             
             this._wasModified();
         }
         return true;
     };
+    
+    /**
+     * @private
+     * Removes a file extension from this language
+     * @param {string} extension File extension to remove
+     */
+    Language.prototype._removeFileExtension = function (extension) {
+        var index = this._fileExtensions.indexOf(extension);
+        if (index === -1) {
+            return;
+        }
+        
+        this._fileExtensions.splice(index, 1);
+        this._wasModified();
+    };
 
+    /**
+     * @private
+     * Removes a file name from this language
+     * @param {string} fileName File name to remove
+     */
+    Language.prototype._removeFileName = function (fileName) {
+        var index = this._fileNames.indexOf(fileName);
+        if (index === -1) {
+            return;
+        }
+        
+        this._fileNames.splice(index, 1);
+        this._wasModified();
+    };
+    
     /**
      * Returns whether the line comment syntax is defined for this language.
      * @return {boolean} Whether line comments are supported
      */
     Language.prototype.hasLineCommentSyntax = function () {
-        return this._lineCommentSyntax.length > 0;
+        // Cast as Boolean to return false instead of null (i.e. this._parent)
+        return Boolean(this._lineCommentSyntax.length > 0 || (this._parent && this._parent.hasLineCommentSyntax()));
     };
     
     /**
@@ -517,7 +657,7 @@ define(function (require, exports, module) {
      * @return {Array.<string>} The prefixes
      */
     Language.prototype.getLineCommentPrefixes = function () {
-        return this._lineCommentSyntax;
+        return this._lineCommentSyntax.concat(this._parent ? this._parent.getLineCommentPrefixes() : []);
     };
 
     /**
@@ -550,7 +690,8 @@ define(function (require, exports, module) {
      * @return {boolean} Whether block comments are supported
      */
     Language.prototype.hasBlockCommentSyntax = function () {
-        return Boolean(this._blockCommentSyntax);
+        // Cast as Boolean to return false instead of null (i.e. this._parent)
+        return Boolean(this._blockCommentSyntax || (this._parent && this._parent.hasBlockCommentSyntax()));
     };
     
     /**
@@ -558,7 +699,7 @@ define(function (require, exports, module) {
      * @return {string} The prefix
      */
     Language.prototype.getBlockCommentPrefix = function () {
-        return this._blockCommentSyntax && this._blockCommentSyntax.prefix;
+        return (this._blockCommentSyntax && this._blockCommentSyntax.prefix) || (this._parent && this._parent.getBlockCommentPrefix());
     };
 
     /**
@@ -566,7 +707,7 @@ define(function (require, exports, module) {
      * @return {string} The suffix
      */
     Language.prototype.getBlockCommentSuffix = function () {
-        return this._blockCommentSyntax && this._blockCommentSyntax.suffix;
+        return (this._blockCommentSyntax && this._blockCommentSyntax.suffix) || (this._parent && this._parent.getBlockCommentSuffix());
     };
     
     /**
@@ -593,10 +734,10 @@ define(function (require, exports, module) {
      * @return {Language} This language if it uses the mode, or whatever {@link LanguageManager#_getLanguageForMode} returns
      */
     Language.prototype.getLanguageForMode = function (mode) {
-        if (mode === this._mode) {
+        if (mode === this.getMode()) {
             return this;
         }
-        return this._modeToLanguageMap[mode] || _getLanguageForMode(mode);
+        return this._modeToLanguageMap[mode] || (this._parent && this._parent.getLanguageForMode(mode)) || _getLanguageForMode(mode);
     };
 
     /**
@@ -608,7 +749,7 @@ define(function (require, exports, module) {
      * @private
      */
     Language.prototype._setLanguageForMode = function (mode, language) {
-        if (mode === this._mode && language !== this) {
+        if (mode === this.getMode() && language !== this) {
             console.error("A language must always map its mode to itself");
             return false;
         }
@@ -663,8 +804,9 @@ define(function (require, exports, module) {
             result.reject("Language \"" + id + "\" is already defined");
             return result.promise();
         }
-
+        
         var language       = new Language(),
+            parent         = definition.parent,
             name           = definition.name,
             fileExtensions = definition.fileExtensions,
             fileNames      = definition.fileNames,
@@ -674,8 +816,9 @@ define(function (require, exports, module) {
             l;
         
         if (!language._setId(id) || !language._setName(name) ||
+                (parent       && !language._setParent(parent)) ||
                 (blockComment && !language.setBlockCommentSyntax(blockComment[0], blockComment[1])) ||
-                (lineComment && !language.setLineCommentSyntax(lineComment))) {
+                (lineComment  && !language.setLineCommentSyntax(lineComment))) {
             result.reject();
             return result.promise();
         }
diff --git a/src/search/QuickOpen.js b/src/search/QuickOpen.js
index 4f7243ba4d4..c2bff75d6fd 100644
--- a/src/search/QuickOpen.js
+++ b/src/search/QuickOpen.js
@@ -542,13 +542,13 @@ define(function (require, exports, module) {
         // Try to invoke a search plugin
         var curDoc = DocumentManager.getCurrentDocument();
         if (curDoc) {
-            var languageId = curDoc.getLanguage().getId();
+            var language = curDoc.getLanguage();
 
             var i;
             for (i = 0; i < plugins.length; i++) {
                 var plugin = plugins[i];
-                var languageIdMatch = plugin.languageIds.indexOf(languageId) !== -1 || plugin.languageIds.length === 0;
-                if (languageIdMatch && plugin.match && plugin.match(query)) {
+                var languageMatch = plugin.languageIds.length === 0 || language.isInstanceOfLanguageInArray(plugin.languageIds);
+                if (languageMatch && plugin.match && plugin.match(query)) {
                     currentPlugin = plugin;
                     
                     // Look up the StringMatcher for this plugin.
diff --git a/test/spec/LanguageManager-test.js b/test/spec/LanguageManager-test.js
index 100694a6e26..b7794a4bc2e 100644
--- a/test/spec/LanguageManager-test.js
+++ b/test/spec/LanguageManager-test.js
@@ -46,11 +46,14 @@ define(function (require, exports, module) {
         function defineLanguage(definition) {
             var def = $.extend({}, definition);
             
+            var id = def.id;
+            delete def.id;
+            
             if (def.blockComment) {
                 def.blockComment = [def.blockComment.prefix, def.blockComment.suffix];
             }
             
-            return LanguageManager.defineLanguage(definition.id, def);
+            return LanguageManager.defineLanguage(id, def);
         }
         
         function validateLanguage(expected, actual) {
@@ -379,6 +382,153 @@ define(function (require, exports, module) {
                 });
             });
             
+            describe("when extending a language", function () {
+                var id          = "fakescript",
+                    name        = "FakeScript",
+                    fileName    = "fakefile",
+                    extension   = "fake",
+                    parent      = LanguageManager.getLanguage("javascript"),
+                    child,
+                    promise,
+                    didFail,
+                    def,
+                    language;
+                
+            
+                it("should still require a name", function () {
+                    expect(LanguageManager.getLanguage(id)).toBe(undefined);
+                    defineLanguage({ id: id, parent: parent.getId() });
+                    expect(console.error).toHaveBeenCalledWith("name must be a string");
+                });
+                
+                it("should allow a minimal definition when extending a language", function () {
+                    runs(function () {
+                        expect(LanguageManager.getLanguage(id)).toBe(undefined);
+                        promise = defineLanguage({ id: id, parent: parent.getId(), name: name });
+                        promise.done(function (language) {
+                            child = language;
+                        });
+                    });
+                    
+                    runs(function () {
+                        waitsForDone(promise, "Defining a language with a name should succeed");
+                    });
+                });
+
+                it("make the inheritance chain comprehensible", function () {
+                    // isLanguage
+                    
+                    // Same language: true
+                    expect(child.isLanguage(child)).toBe(true);
+                    expect(child.isLanguage(child.getId())).toBe(true);
+                    expect(parent.isLanguage(parent)).toBe(true);
+                    expect(parent.isLanguage(parent.getId())).toBe(true);
+                    // Different language: false
+                    expect(child.isLanguage(parent)).toBe(false);
+                    expect(child.isLanguage(parent.getId())).toBe(false);
+                    expect(parent.isLanguage(child)).toBe(false);
+                    expect(parent.isLanguage(child.getId())).toBe(false);
+                    
+                    // isBasedOnLanguage
+                    
+                    // Same language: false
+                    expect(child.isBasedOnLanguage(child)).toBe(false);
+                    expect(child.isBasedOnLanguage(child.getId())).toBe(false);
+                    expect(parent.isBasedOnLanguage(parent)).toBe(false);
+                    expect(parent.isBasedOnLanguage(parent.getId())).toBe(false);
+                    // Child based on parent: true, parent based on child: false
+                    expect(child.isBasedOnLanguage(parent)).toBe(true);
+                    expect(child.isBasedOnLanguage(parent.getId())).toBe(true);
+                    expect(parent.isBasedOnLanguage(child)).toBe(false);
+                    expect(parent.isBasedOnLanguage(child.getId())).toBe(false);
+                    
+                    // isInstanceOfLanguage
+                    
+                    // Same language: true
+                    expect(child.isInstanceOfLanguage(child)).toBe(true);
+                    expect(child.isInstanceOfLanguage(child.getId())).toBe(true);
+                    expect(parent.isInstanceOfLanguage(parent)).toBe(true);
+                    expect(parent.isInstanceOfLanguage(parent.getId())).toBe(true);
+                    // Child instance of parent: true, parent instance of child: false
+                    expect(child.isInstanceOfLanguage(parent)).toBe(true);
+                    expect(child.isInstanceOfLanguage(parent.getId())).toBe(true);
+                    expect(parent.isInstanceOfLanguage(child)).toBe(false);
+                    expect(parent.isInstanceOfLanguage(child.getId())).toBe(false);
+                    
+                    // isInstanceOfLanguageInArray
+                    // No language: false
+                    expect(child.isInstanceOfLanguageInArray([])).toBe(false);
+                    expect(parent.isInstanceOfLanguageInArray([])).toBe(false);
+                    // Same language: true
+                    expect(child.isInstanceOfLanguageInArray([child])).toBe(true);
+                    expect(child.isInstanceOfLanguageInArray([child.getId()])).toBe(true);
+                    expect(parent.isInstanceOfLanguageInArray([parent])).toBe(true);
+                    expect(parent.isInstanceOfLanguageInArray([parent.getId()])).toBe(true);
+                    // Child instance of parent: true, parent instance of child: false
+                    expect(child.isInstanceOfLanguageInArray([parent])).toBe(true);
+                    expect(child.isInstanceOfLanguageInArray([parent.getId()])).toBe(true);
+                    expect(parent.isInstanceOfLanguageInArray([child])).toBe(false);
+                    expect(parent.isInstanceOfLanguageInArray([child.getId()])).toBe(false);
+                    // Both languages: true
+                    expect(child.isInstanceOfLanguageInArray([child, parent])).toBe(true);
+                    expect(child.isInstanceOfLanguageInArray([child.getId(), parent.getId()])).toBe(true);
+                    expect(parent.isInstanceOfLanguageInArray([child, parent])).toBe(true);
+                    expect(parent.isInstanceOfLanguageInArray([child.getId(), parent.getId()])).toBe(true);
+                    
+                    var object = {};
+                    expect(child.findEntryInObject(object)).toBeFalsy();
+                    expect(parent.findEntryInObject(object)).toBeFalsy();
+                    
+                    object[parent.getId()] = "parent";
+                    expect(child.findEntryInObject(object)).toBe("parent");
+                    expect(parent.findEntryInObject(object)).toBe("parent");
+                    
+                    object[child.getId()] = "child";
+                    expect(child.findEntryInObject(object)).toBe("child");
+                    expect(parent.findEntryInObject(object)).toBe("parent");
+                    
+                    delete object[parent.getId()];
+                    expect(child.findEntryInObject(object)).toBe("child");
+                    expect(parent.findEntryInObject(object)).toBeFalsy();
+                });
+                
+                it("inherit only mode and comment syntax", function () {
+                    runs(function () {
+                        // Own
+                        expect(child.getId()).toBe(id);
+                        expect(child.getName()).toBe(name);
+                        expect(child.getFileExtensions()).toEqual([]);
+                        
+                        // Inherited
+                        expect(child.getMode()).toBe(parent.getMode());
+                        
+                        expect(child.hasLineCommentSyntax()).toBe(parent.hasLineCommentSyntax());
+                        expect(child.getLineCommentPrefixes()).toEqual(parent.getLineCommentPrefixes());
+                        
+                        expect(child.hasBlockCommentSyntax()).toBe(parent.hasBlockCommentSyntax());
+                        expect(child.getBlockCommentPrefix()).toBe(parent.getBlockCommentPrefix());
+                        expect(child.getBlockCommentSuffix()).toBe(parent.getBlockCommentSuffix());
+                    });
+                });
+                
+                it("should take over file names and extension from parent", function () {
+                    parent.addFileExtension(extension);
+                    expect(child.getFileExtensions()).not.toContain(extension);
+                    expect(parent.getFileExtensions()).toContain(extension);
+                    parent.addFileName(fileName);
+                    expect(child.getFileNames()).not.toContain(fileName);
+                    expect(parent.getFileNames()).toContain(fileName);
+                    expect(LanguageManager.getLanguageForPath("file." + extension).getId()).toBe(parent.getId());
+                    
+                    child.addFileExtension(extension);
+                    expect(child.getFileExtensions()).toContain(extension);
+                    expect(parent.getFileExtensions()).not.toContain(extension);
+                    child.addFileName(fileName);
+                    expect(child.getFileNames()).toContain(fileName);
+                    expect(parent.getFileNames()).not.toContain(fileName);
+                    expect(LanguageManager.getLanguageForPath(fileName).getId()).toBe(child.getId());
+                });
+            });
         });
         
         describe("rename file extension", function () {
@@ -448,7 +598,9 @@ define(function (require, exports, module) {
                 // cleanup
                 doc.releaseRef();
             });
-
+        });
+            
+        describe("adding or modifying languages", function () {
             it("should update the document's language when a language is added", function () {
                 var unknown,
                     doc,