Merge commit '855e99d105eef8898c872013871b7c57d9381262'
diff --git a/bundles/org.eclipse.orion.client.editor/web/orion/editor/contentAssist.js b/bundles/org.eclipse.orion.client.editor/web/orion/editor/contentAssist.js
index ff703ea..cca7c6b 100644
--- a/bundles/org.eclipse.orion.client.editor/web/orion/editor/contentAssist.js
+++ b/bundles/org.eclipse.orion.client.editor/web/orion/editor/contentAssist.js
@@ -13,20 +13,23 @@
 
 
 /**
- * @namespace The global container for eclipse APIs.
+ * @namespace The container for Orion APIs.
  */ 
 	var orion = orion || {};
 	orion.editor = orion.editor || {};
 
 /**
- * A ContentAssist will look for content assist providers in the service registry (if provided).
- * Alternately providers can be registered directly by calling {@link #addProvider}.
- * @name eclipse.ContentAssist
- * @param {orion.editor.Editor} editor
- * @param {String} contentAssistId
- * @param {eclipse.ServiceRegistry} [serviceRegistry] If omitted, providers must be registered via {@link #addProvider}.
+ * A <tt>ContentAssist</tt> will look for content assist providers in the service registry (if provided).
+ * Alternatively, providers can be registered directly by calling {@link #addProvider}.
+ * @name orion.editor.ContentAssist
+ * @class Can be attached to an Editor to display content assist suggestions.
+ * @param {orion.editor.Editor} editor The Editor to provide content assist for.
+ * @param {String|DomNode} contentAssistId The ID or DOMNode to use as the parent for content assist.
+ * @param {orion.ServiceRegistry} [serviceRegistry] Service registry to use for looking up content assist providers.
+ * If this parameter is omitted, providers must instead be registered by calling {@link #addProvider}.
  */
 orion.editor.ContentAssist = (function() {
+	/** @private */
 	function ContentAssist(editor, contentAssistId, serviceRegistry) {
 		this.editor = editor;
 		this.textView = editor.getTextView();
@@ -47,7 +50,7 @@
 		};
 		this.init();
 	}
-	ContentAssist.prototype = {
+	ContentAssist.prototype = /** @lends orion.editor.ContentAssist.prototype */ {
 		init: function() {
 			var isMac = navigator.platform.indexOf("Mac") !== -1;
 			this.textView.setKeyBinding(isMac ? new orion.textview.KeyBinding(' ', false, false, false, true) : new orion.textview.KeyBinding(' ', true), "Content Assist");
@@ -57,8 +60,8 @@
 			}));
 			dojo.connect(this.editor, "onInputChange", this, this.inputChanged);
 		},
-	
-		inputChanged: function(fileName) {
+		/** @private */
+		inputChanged: function(/**String*/ fileName) {
 			if (this.serviceRegistry) {
 				// Filter the ServiceReferences
 				this.activeServiceReferences = [];
@@ -83,7 +86,6 @@
 				}
 			}
 		},
-		
 		cancel: function() {
 			this.showContentAssist(false);
 		},
@@ -136,7 +138,7 @@
 				return true;
 			}
 		},
-		showContentAssist: function(enable) {
+		showContentAssist: function(/**Boolean*/ enable) {
 			if (!this.contentAssistPanel) {
 				return;
 			}
@@ -199,10 +201,9 @@
 			}
 		},
 		/**
-		 * @param {String} The string buffer.substring(w+1, c) where c is the caret offset and w is the index of the 
-		 * rightmost whitespace character preceding c.
-		 * @param {String} buffer The entire buffer being edited
-		 * @param {eclipse.Selection} selection The current textView selection.
+		 * @param {String} prefix A prefix against which content assist proposals should be evaluated.
+		 * @param {String} buffer The entire buffer being edited.
+		 * @param {orion.textview.Selection} selection The current selection from the Editor.
 		 * @returns {dojo.Deferred} A future that will provide the keywords.
 		 */
 		getKeywords: function(prefix, buffer, selection) {
@@ -243,7 +244,7 @@
 		 * Adds a content assist provider.
 		 * @param {Object} provider The provider object. See {@link orion.contentAssist.CssContentAssistProvider} for an example.
 		 * @param {String} name Name for this provider.
-		 * @param {String} pattern The regex pattern matching filenames that provider can offer content assist for.
+		 * @param {String} pattern A regex pattern matching filenames that <tt>provider</tt> can offer content assist for.
 		 */
 		addProvider: function(provider, name, pattern) {
 			this.contentAssistProviders = this.contentAssistProviders || [];
diff --git a/bundles/org.eclipse.orion.client.editor/web/orion/editor/editor.js b/bundles/org.eclipse.orion.client.editor/web/orion/editor/editor.js
index d662cad..106ecf8 100644
--- a/bundles/org.eclipse.orion.client.editor/web/orion/editor/editor.js
+++ b/bundles/org.eclipse.orion.client.editor/web/orion/editor/editor.js
@@ -13,8 +13,33 @@
 
 var orion = orion || {};
 orion.editor = orion.editor || {};	
-	
+
+/**
+ * @name orion.editor.Editor
+ * @class An <code>Editor</code> is a user interface for editing text that provides additional features over the basic {@link orion.textview.TextView}.
+ * Some of <code>Editor</code>'s features include:
+ * <ul>
+ * <li>Additional actions and key bindings for editing text</li>
+ * <li>Content assist</li>
+ * <li>Find and Incremental Find</li>
+ * <li>Rulers for displaying line numbers and annotations</li>
+ * <li>Status reporting</li>
+ * </ul>
+ * 
+ * @description Creates a new Editor with the given options.
+ * @param {Object} options Options controlling the features of this Editor.
+ * @param {Object} options.annotationFactory
+ * @param {Object} options.contentAssistFactory
+ * @param {Object} options.domNode
+ * @param {Object} options.keyBindingFactory
+ * @param {Object} options.lineNumberRulerFactory
+ * @param {Object} options.statusReporter
+ * @param {Object} options.syntaxHighlightProviders
+ * @param {Object} options.textViewFactory
+ * @param {Object} options.undoStackFactory
+ */
 orion.editor.Editor = (function() {
+	/** @private */
 	function Editor(options) {
 		this._textViewFactory = options.textViewFactory;
 		this._undoStackFactory = options.undoStackFactory;
@@ -32,11 +57,18 @@
 		this._contentAssist = null;
 		this._keyModes = [];		
 	}
-	Editor.prototype = {
+	Editor.prototype = /** @lends orion.editor.Editor.prototype */ {
+		/**
+		 * Returns the underlying <code>TextView</code> used by this editor. 
+		 * @returns orion.textview.TextView
+		 */
 		getTextView: function() {
 			return this._textView;
 		},
 		
+		/**
+		 * @private
+		 */
 		reportStatus: function(message, isError) {
 			if (this._statusReporter) {
 				this._statusReporter(message, isError);
@@ -47,9 +79,10 @@
 				
 		/**
 		 * @static
-		 * @param textView
-		 * @param start
-		 * @param end
+		 * @param {orion.textview.TextView} textView
+		 * @param {Number} start
+		 * @param {Number} [end]
+		 * @private
 		 */
 		moveSelection: function(textView, start, end) {
 			end = end || start;
@@ -79,14 +112,23 @@
 				textView.focus();
 			}
 		},
+		/**
+		 * Returns the current contents of the editor. 
+		 * @returns {String}
+		 */
 		getContents : function() {
 			if (this._textView) {
 				return this._textView.getText();
 			}
 		},
+		/**
+		 * Returns <code>true</code> if the editor is dirty; <code>false</code> otherwise.
+		 * @returns {Boolean} 
+		 */
 		isDirty : function() {
 			return this._dirty;
 		},
+		/** @private */
 		checkDirty : function() {
 			var dirty = !this._undoStack.isClean();
 			if (this._dirty === dirty) {
@@ -95,17 +137,23 @@
 			this.onDirtyChange(dirty);
 		},
 		
+		/**
+		 * @returns {Object}
+		 */
 		getAnnotationsRuler : function() {
 			return this._annotationsRuler;
 		},
 
 		/**
-		 * Helper for finding occurrences of str in the textView.
-		 * @param str {String}
-		 * @param startIndex {number}
-		 * @param [ignoreCase] {boolean} Default is false
-		 * @param [reverse] {boolean} Default is false
-		 * @return {index: number, length: number} giving the match details, or null if no match found.
+		 * Helper for finding occurrences of str in the editor contents.
+		 * @param {String} str
+		 * @param {Number} startIndex
+		 * @param {Boolean} [ignoreCase] Default is false.
+		 * @param {Boolean} [reverse] Default is false.
+		 * @return {Object} An object giving the match details, or <code>null</code> if no match found. The returned 
+		 * object will have the properties:<br />
+		 * {Number} index<br />
+		 * {Number} length 
 		 */
 		doFind: function(str, startIndex, ignoreCase, reverse) {
 			var text = this._textView.getText();
@@ -133,12 +181,15 @@
 		},
 		
 		/**
-		 * Helper for finding regexp matches in the textView. Use doFind() for simple string searches.
-		 * @param pattern {String} A valid regexp pattern
-		 * @param flags {String} Valid regexp flags: [is]
-		 * @param [startIndex] {number} Default is false
-		 * @param [reverse] {boolean} Default is false
-		 * @return {index: number, length: number} giving the match details, or null if no match found.
+		 * Helper for finding regex matches in the editor contents. Use {@link #doFind} for simple string searches.
+		 * @param {String} pattern A valid regexp pattern.
+		 * @param {String} flags Valid regexp flags: [is]
+		 * @param {Number} [startIndex] Default is false.
+		 * @param {Boolean} [reverse] Default is false.
+		 * @return {Object} An object giving the match details, or <code>null</code> if no match found. The returned object
+		 * will have the properties:<br />
+		 * {Number} index<br />
+		 * {Number} length 
 		 */
 		doFindRegExp: function(pattern, flags, startIndex, reverse) {
 			if (!pattern) {
@@ -168,8 +219,10 @@
 		},
 		
 		/**
+		 * @private
+		 * @static
 		 * @param {String} Input string
-		 * @return {pattern:String, flags:String} if str looks like a RegExp, or null otherwise
+		 * @returns {pattern:String, flags:String} if str looks like a RegExp, or null otherwise
 		 */
 		parseRegExp: function(str) {
 			var regexp = /^\s*\/(.+)\/([gim]{0,3})\s*$/.exec(str);
@@ -179,6 +232,9 @@
 			return null;
 		},
 		
+		/**
+		 * Creates the underlying TextView and installs the editor's features.
+		 */
 		installTextView : function() {
 			// Create textView and install optional features
 			this._textView = this._textViewFactory();
@@ -226,7 +282,7 @@
 				return false;
 			}));
 						
-			/**@this {orion.editor.Editor} */
+			/** @this {orion.editor.Editor} */
 			function updateCursorStatus() {
 				var model = textView.getModel();
 				var caretOffset = textView.getCaretOffset();
@@ -277,6 +333,14 @@
 			}
 		},
 		
+		/**
+		 * Reveals and selects a portion of text.
+		 * @param {Number} start
+		 * @param {Number} end
+		 * @param {Number} line
+		 * @param {Number} offset
+		 * @param {Number} length
+		 */
 		showSelection : function(start, end, line, offset, length) {
 			// We use typeof because we need to distinguish the number 0 from an undefined or null parameter
 			if (typeof(start) === "number") {
@@ -296,6 +360,13 @@
 			}
 		},
 		
+		/**
+		 * Called when the editor's contents have changed.
+		 * @param {String} title
+		 * @param {String} message
+		 * @param {String} contents
+		 * @param {Boolean} contentsSaved
+		 */
 		onInputChange : function (title, message, contents, contentsSaved) {
 			if (contentsSaved && this._textView) {
 				// don't reset undo stack on save, just mark it clean so that we don't lose the undo past the save
@@ -317,6 +388,12 @@
 			}
 		},
 		
+		/**
+		 * Reveals a line in the editor, and optionally selects a portion of the line.
+		 * @param {Number} line
+		 * @param {Number|String} column
+		 * @param {Number} [end]
+		 */
 		onGotoLine : function (line, column, end) {
 			if (this._textView) {
 				var lineStart = this._textView.getModel().getLineStart(line);
@@ -338,6 +415,10 @@
 			}
 		},
 		
+		/**
+		 * Called when the dirty state of the editor is changing.
+		 * @param {Boolean} isDirty
+		 */
 		onDirtyChange: function(isDirty) {
 			this._dirty = isDirty;
 		}
diff --git a/bundles/org.eclipse.orion.client.editor/web/orion/editor/editorFeatures.js b/bundles/org.eclipse.orion.client.editor/web/orion/editor/editorFeatures.js
index 06a2b3c..88da79a 100644
--- a/bundles/org.eclipse.orion.client.editor/web/orion/editor/editorFeatures.js
+++ b/bundles/org.eclipse.orion.client.editor/web/orion/editor/editorFeatures.js
@@ -13,9 +13,8 @@
 
 
 /**
- * @namespace The global container for orion APIs.
+ * @namespace The container for Orion APIs.
  */ 
-
 var orion = orion || {};
 orion.editor = orion.editor || {};	
 
diff --git a/bundles/org.eclipse.orion.client.editor/web/orion/editor/textMateStyler.js b/bundles/org.eclipse.orion.client.editor/web/orion/editor/textMateStyler.js
index f04315a..e5ca948 100644
--- a/bundles/org.eclipse.orion.client.editor/web/orion/editor/textMateStyler.js
+++ b/bundles/org.eclipse.orion.client.editor/web/orion/editor/textMateStyler.js
@@ -15,10 +15,10 @@
 orion.editor = orion.editor || {};
 
 /**
- * A styler that does nothing, but can be extended by concrete stylers. Extenders can call 
- * {@link orion.editor.AbstractStyler.extend} and provide their own {@link #_onSelection}, 
- * {@link #_onModelChanged}, {@link #_onDestroy} and {@link #_onLineStyle} methods.
- * @class orion.editor.AbstractStyler
+ * @class A styler that does nothing, but can be extended by concrete stylers. To extend, call 
+ * {@link orion.editor.AbstractStyler.extend} and provide implementations of one or more of
+ * the {@link #_onSelection}, {@link #_onModelChanged}, {@link #_onDestroy} and {@link #_onLineStyle} methods.
+ * @name orion.editor.AbstractStyler
  */
 orion.editor.AbstractStyler = (function() {
 	/** @inner */
@@ -26,8 +26,9 @@
 	}
 	AbstractStyler.prototype = /** @lends orion.editor.AbstractStyler.prototype */ {
 		/**
-		 * Initializes this styler with a textView. Extenders <b>must</b> call this from their constructor.
-		 * @param {orion.textview.TextView} textView
+		 * Initializes this styler with a TextView. If you are extending AbstractStyler,
+		 * you <b>must</b> call this from your subclass's constructor function.
+		 * @param {orion.textview.TextView} textView The TextView to provide styling for.
 		 */
 		initialize: function(textView) {
 			this.textView = textView;
@@ -38,10 +39,7 @@
 			textView.addEventListener("LineStyle", this, this._onLineStyle);
 			textView.redrawLines();
 		},
-		
-		/**
-		 * Destroys this styler and removes all listeners. Called by the editor.
-		 */
+		/** Destroys this styler and removes all listeners. Called by the editor. */
 		destroy: function() {
 			if (this.textView) {
 				this.textView.removeEventListener("Selection", this, this._onSelection);
@@ -51,39 +49,34 @@
 				this.textView = null;
 			}
 		},
-		
 		/** To be overridden by subclass.
 		 * @public
 		 */
-		_onSelection: function(/**eclipse.SelectionEvent*/ e) {},
-		
+		_onSelection: function(/**eclipse.SelectionEvent*/ selectionEvent) {},
 		/** To be overridden by subclass.
 		 * @public
 		 */
-		_onModelChanged: function(/**eclipse.ModelChangedEvent*/ e) {},
-		
+		_onModelChanged: function(/**eclipse.ModelChangedEvent*/ modelChangedEvent) {},
 		/** To be overridden by subclass.
 		 * @public
 		 */
-		_onDestroy: function(/**eclipse.DestroyEvent*/ e) {},
-		
+		_onDestroy: function(/**eclipse.DestroyEvent*/ destroyEvent) {},
 		/** To be overridden by subclass.
 		 * @public
 		 */
-		_onLineStyle: function(/**eclipse.LineStyleEvent*/ e) {}
+		_onLineStyle: function(/**eclipse.LineStyleEvent*/ lineStyleEvent) {}
 	};
 	
 	return AbstractStyler;
 }());
 
 /**
- * Helper for extending AbstractStyler.
+ * Helper for extending {@link orion.editor.AbstractStyler}.
  * @methodOf orion.editor.AbstractStyler
  * @static
  * @param {Function} subCtor The constructor function for the subclass.
- * @param {Object} [proto] Object to be mixed into the subclass's prototype. This object can contain your 
- * implementation of _onSelection, _onModelChanged, etc.
- * @see orion.editor.TextMateStyler for example usage.
+ * @param {Object} [proto] Object to be mixed into the subclass's prototype. This object should 
+ * contain your implementation of _onSelection, _onModelChanged, etc.
  */
 orion.editor.AbstractStyler.extend = function(subCtor, proto) {
 	if (typeof(subCtor) !== "function") { throw new Error("Function expected"); }
@@ -205,8 +198,8 @@
 		return (/\\\d+/).test(regex.source);
 	},
 	
-	/** @returns {RegExp} A regex made by substituting any backreferences in <tt>regex</tt> for the value of the property
-	 * in <tt>sub</tt> with the same name as the backreferenced group number. */
+	/** @returns {RegExp} A regex made by substituting any backreferences in <code>regex</code> for the value of the property
+	 * in <code>sub</code> with the same name as the backreferenced group number. */
 	getSubstitutedRegex: function(/**RegExp*/ regex, /**Object*/ sub, /**Boolean*/ escape) {
 		escape = (typeof escape === "undefined") ? true : false;
 		var exploded = regex.source.split(/(\\\d+)/g);
@@ -230,7 +223,7 @@
 	},
 	
 	/**
-	 * Builds a version of <tt>regex</tt> with every non-capturing term converted into a capturing group. This is a workaround
+	 * Builds a version of <code>regex</code> with every non-capturing term converted into a capturing group. This is a workaround
 	 * for JavaScript's lack of API to get the index at which a matched group begins in the input string.<p>
 	 * Using the "groupified" regex, we can sum the lengths of matches from <i>consuming groups</i> 1..n-1 to obtain the 
 	 * starting index of group n. (A consuming group is a capturing group that is not inside a lookahead assertion).</p>
@@ -240,7 +233,7 @@
 	 * @param {Object} [backRefOld2NewMap] Optional. If provided, the backreference numbers in regex will be updated using the 
 	 * properties of this object rather than the new group numbers of regex itself.
 	 * <ul><li>[0] {RegExp} The groupified version of the input regex.</li>
-	 * <li>[1] {Object} A map containing old-group to new-group info. Each property is a capturing group number of <tt>regex</tt>
+	 * <li>[1] {Object} A map containing old-group to new-group info. Each property is a capturing group number of <code>regex</code>
 	 * and its value is the corresponding capturing group number of [0].</li>
 	 * <li>[2] {Object} A map indicating which capturing groups of [0] are also consuming groups. If a group number is found
 	 * as a property in this object, then it's a consuming group.</li></ul>
@@ -405,55 +398,65 @@
 };
 
 /**
- * A styler that knows how to apply a limited subset of the TextMate grammar format to style a line.<p>
+ * @name orion.editor.TextMateStyler
+ * @class A styler that knows how to apply a subset of the TextMate grammar format to style a line.<p>
  *
  * <h4>Styling from a grammar:</h4>
  * Each scope name given in the grammar is converted to an array of CSS class names. For example 
- * a region of text with scope <tt>keyword.control.php</tt> will be assigned the CSS classes 
- * <pre>keyword, keyword-control, keyword-control-php</pre>
+ * a region of text with scope <code>keyword.control.php</code> will be assigned the CSS classes<br />
+ * <code>keyword, keyword-control, keyword-control-php</code>
  *
  * A CSS file can give rules matching any of these class names to provide generic or more specific styling.
- * For example, <pre>.keyword { font-color: blue; }</pre> colors all keywords blue, while
- * <pre>.keyword-control-php { font-weight: bold; }</pre> bolds only PHP control keywords.
+ * For example, <br /><code>.keyword { font-color: blue; }</code> colors all keywords blue, while<br />
+ * <code>.keyword-control-php { font-weight: bold; }</code> bolds only PHP control keywords.<p>
  *
  * This is useful when using grammars that adhere to TextMate's
  * <a href="http://manual.macromates.com/en/language_grammars.html#naming_conventions">scope name conventions</a>,
  * as a single CSS rule can provide consistent styling to similar constructs across different languages.<p>
  * 
- * <h4>Supported top-level grammar features:</h4>
- * <ul><li><tt>fileTypes, patterns, repository</tt> (but see below) are supported.</li>
- * <li><tt>scopeName, firstLineMatch, foldingStartMarker, foldingStopMarker</tt> are <b>not</b> supported.</li>
+ * <h4>Top-level grammar constructs:</h4>
+ * <ul><li><code>patterns, repository</code> (with limitations, see "Other Features") are supported.</li>
+ * <li><code>scopeName, firstLineMatch, foldingStartMarker, foldingStopMarker</code> are <b>not</b> supported.</li>
+ * <li><code>fileTypes</code> is <b>not</b> supported. When using the Orion service registry, the "orion.edit.highlighter"
+ * service serves a similar purpose.
  * </ul>
  *
- * <p>TODO update this section</p>
- * <del>
- * <h4>Supported grammar rule features:</h4>
- * <ul><li><tt>match</tt> patterns are supported.</li>
- * <li><tt>name</tt> scope is supported.</li>
- * <li><tt>captures</tt> is <b>not</b> supported. Any scopes given inside a <tt>captures</tt> object are not applied.</li>
- * <li><tt>begin/end</tt> patterns are <b>not</b> supported and are ignored, along with their subrules. Consequently, 
- *   matched constructs may <b>not</b> span multiple lines.</li>
- * <li><tt>contentName, beginCaptures, endCaptures, applyEndPatternLast</tt> are <b>not</b> supported.</li>
- * <li><tt>include</tt> is supported, but only when it references a rule in the current grammar's <tt>repository</tt>.
- *   Including <tt>$self</tt>, <tt>$base</tt>, or <tt>rule.from.another.grammar</tt> is <b>not</b> supported.</li>
- * <li>The <tt>(?x)</tt> option ("extended" regex format) is supported, but only when it appears at the beginning of a regex pattern.</li>
- * <li>Matching is done using native JavaScript {@link RegExp}s. As a result, many Oniguruma features are <b>not</b> supported.
- *   Unsupported features include:
+ * <h4>Regular expression constructs:</h4>
+ * <ul>
+ * <li><code>match</code> patterns are supported.</li>
+ * <li><code>begin .. end</code> patterns are supported.</li>
+ * <li>The "extended" regex forms <code>(?x)</code> and <code>(?x:...)</code> are supported, but <b>only</b> when they 
+ * apply to the entire regex pattern.</li>
+ * <li>Matching is done using native JavaScript <code>RegExp</code>s. As a result, many features of the Oniguruma regex
+ * engine used by TextMate are <b>not</b> supported.
+ * Unsupported features include:
  *   <ul><li>Named captures</li>
- *   <li>Setting flags inside groups (eg. <tt>(?i:a)b</tt>)</li>
+ *   <li>Setting flags inside subgroups (eg. <code>(?i:a)b</code>)</li>
  *   <li>Lookbehind and negative lookbehind</li>
  *   <li>Subexpression call</li>
  *   <li>etc.</li>
  *   </ul>
  * </li>
  * </ul>
+ * 
+ * <h4>Scope-assignment constructs:</h4>
+ * <ul>
+ * <li><code>captures, beginCaptures, endCaptures</code> are supported.</li>
+ * <li><code>name</code> and <code>contentName</code> are supported.</li>
+ * </ul>
+ * 
+ * <h4>Other features:</h4>
+ * <ul>
+ * <li><code>applyEndPatternLast</code> is supported.</li>
+ * <li><code>include</code> is supported, but only when it references a rule in the current grammar's <code>repository</code>.
+ * Including <code>$self</code>, <code>$base</code>, or <code>rule.from.another.grammar</code> is <b>not</b> supported.</li>
+ * </ul>
  * </del>
- *
- * @class orion.editor.TextMateStyler
+ * @description Creates a new TextMateStyler.
  * @extends orion.editor.AbstractStyler
- * @param {orion.textview.TextView} textView The textView.
- * @param {Object} grammar The TextMate grammar as a JavaScript object. You can use a plist-to-JavaScript conversion tool 
- * to produce this object. Note that some features of TextMate grammars are not supported.
+ * @param {orion.textview.TextView} textView The TextView to provide styling for.
+ * @param {Object} grammar The TextMate grammar as a JavaScript object. You can produce this object by running a 
+ * PList-to-JavaScript conversion tool on a <code>.tmLanguage</code> file.
  */
 orion.editor.TextMateStyler = (function() {
 	/** @inner */
@@ -467,9 +470,11 @@
 		this.preprocess();
 	}
 	orion.editor.AbstractStyler.extend(TextMateStyler, /** @lends orion.editor.TextMateStyler.prototype */ {
+		/** @private */
 		copy: function(obj) {
 			return JSON.parse(JSON.stringify(obj));
 		},
+		/** @private */
 		preprocess: function() {
 			var stack = [this.grammar];
 			for (; stack.length !== 0; ) {
@@ -504,6 +509,7 @@
 		},
 		
 		/**
+		 * @private
 		 * Adds eclipse.Style objects for scope to our _styles cache.
 		 * @param {String} scope A scope name, like "constant.character.php".
 		 */
@@ -516,6 +522,7 @@
 //				console.debug("add style for " + scope + " = [" + this._styles[scope].join(", ") + "]");
 			}
 		},
+		/** @private */
 		addStylesForCaptures: function(/**Object*/ captures) {
 			for (var prop in captures) {
 				if (captures.hasOwnProperty(prop)) {
@@ -593,6 +600,7 @@
 		/**
 		 * @param {Object} rule A rule from the grammar.
 		 * @returns {MatchRule|BeginEndRule|ContainerRule}
+		 * @private
 		 */
 		_createTypedRule: function(rule) {
 			if (rule.match) {
@@ -605,6 +613,7 @@
 		},
 		/**
 		 * Resolves a rule from the grammar (which may be an include) into the real rule that it points to.
+		 * @private
 		 */
 		_resolve: function(rule) {
 			var resolved = rule;
@@ -627,6 +636,7 @@
 			}
 			return resolved;
 		},
+		/** @private */
 		ContainerNode: (function() {
 			function ContainerNode(parent, rule) {
 				this.parent = parent;
@@ -645,6 +655,7 @@
 			};
 			return ContainerNode;
 		}()),
+		/** @private */
 		BeginEndNode: (function() {
 			function BeginEndNode(parent, rule, beginMatch) {
 				this.parent = parent;
@@ -699,25 +710,36 @@
 			};
 			return BeginEndNode;
 		}()),
-		/** Pushes rules onto stack so that rules[startFrom] is on top */
+		/** Pushes rules onto stack such that rules[startFrom] is on top
+		 * @private
+		 */
 		push: function(/**Array*/ stack, /**Array*/ rules) {
 			if (!rules) { return; }
 			for (var i = rules.length; i > 0; ) {
 				stack.push(rules[--i]);
 			}
 		},
-		/** Execs regex on text, and returns the match object with its index offset by the given amount. */
+		/** Executes <code>regex</code> on <code>text</code>, and returns the match object with its index 
+		 * offset by the given amount.
+		 * @returns {RegExp.match}
+		 * @private
+		 */
 		exec: function(/**RegExp*/ regex, /**String*/ text, /**Number*/ offset) {
 			var match = regex.exec(text);
 			if (match) { match.index += offset; }
 			regex.lastIndex = 0; // Just in case
 			return match;
 		},
-		/** @returns {Number} The position immediately following the match. */
+		/** @returns {Number} The position immediately following the match.
+		 * @private
+		 */
 		afterMatch: function(/**RegExp.match*/ match) {
 			return match.index + match[0].length;
 		},
-		/** @returns {RegExp.match} If node is a BeginEndNode and its rule's "end" pattern matches the text. */
+		/**
+		 * @returns {RegExp.match} If node is a BeginEndNode and its rule's "end" pattern matches the text.
+		 * @private
+		 */
 		getEndMatch: function(/**Node*/ node, /**String*/ text, /**Number*/ offset) {
 			if (node instanceof this.BeginEndNode) {
 				var rule = node.rule;
@@ -727,7 +749,10 @@
 			}
 			return null;
 		},
-		/** Called once when file is first loaded to build the parse tree. Tree is updated incrementally thereafter as buffer is modified */
+		/** Called once when file is first loaded to build the parse tree. Tree is updated incrementally thereafter 
+		 * as buffer is modified.
+		 * @private
+		 */
 		initialParse: function() {
 			var last = this.textView.getModel().getCharCount();
 			// First time; make parse tree for whole buffer
@@ -766,6 +791,7 @@
 		},
 		/** @returns {BeginEndNode|ContainerNode} The result of taking the first (smallest "start" value) 
 		 * node overlapping [start,end] and drilling down to get its deepest damaged descendant (if any).
+		 * @private
 		 */
 		getFirstDamaged: function(start, end) {
 			// If start === 0 we actually have to start from the root because there is no position
@@ -793,7 +819,9 @@
 			}
 			return result || this._tree;
 		},
-		/** @returns true If n overlaps the interval [start,end] */
+		/** @returns true If <code>n</code> overlaps the interval [start,end].
+		 * @private
+		 */
 		isDamaged: function(/**BeginEndNode*/ n, start, end) {
 			// Note strict > since [2,5] doesn't overlap [5,7]
 			return (n.start <= end && n.end > start);
@@ -809,6 +837,7 @@
 		 * @param {Number} [addedCharCount] Only used for repairing === true
 		 * @param {Number} [removedCharCount] Only used for repairing === true
 		 * @returns {Number} The end position that redrawRange should be called for.
+		 * @private
 		 */
 		parse: function(origNode, repairing, rs, editStart, addedCharCount, removedCharCount) {
 			var model = this.textView.getModel();
@@ -921,6 +950,7 @@
 		},
 		/** Helper for parse() in the repair case. To be called when ending a node, as any children that
 		 * lie in [rs,node.end] and were not repaired must've been deleted.
+		 * @private
 		 */
 		removeUnrepairedChildren: function(node, repairing, start) {
 			if (repairing) {
@@ -938,7 +968,9 @@
 				}
 			}
 		},
-		/** Helper for parse() in the repair case */
+		/** Helper for parse() in the repair case
+		 * @private
+		 */
 		cleanup: function(repairing, origNode, rs, re, eof, addedCharCount, removedCharCount) {
 			var i, node, maybeRepairedNodes;
 			if (repairing) {
@@ -983,6 +1015,7 @@
 		 * {Boolean} isSub
 		 * {RegExp.match} match
 		 * {(Match|BeginEnd)Rule} rule
+		 * @private
 		 */
 		getNextMatch: function(model, node, pos, matchRulesOnly) {
 			var lineIndex = model.getLineAtOffset(pos);
@@ -1047,6 +1080,7 @@
 		 * This is the only time we rely on the start/end values from the pre-change tree. After this 
 		 * we only look at node ordering, never use the old indices.
 		 * @returns {Node}
+		 * @private
 		 */
 		getInitialExpected: function(node, rs) {
 			// TODO: Kind of weird.. maybe ContainerNodes should have start & end set, like BeginEndNodes
@@ -1084,6 +1118,7 @@
 		 * @param {String} event "begin" if the last value of expected was matched as "begin",
 		 *  or "end" if it was matched as an end.
 		 * @returns {Node} The next expected node to match, or null.
+		 * @private
 		 */
 		getNextExpected: function(/**Node*/ expected, event) {
 			var node = expected;
@@ -1107,7 +1142,9 @@
 			}
 			return null;
 		},
-		/** Helper for parse() when repairing. Prunes out the unmatched nodes from the tree so we can continue parsing. */
+		/** Helper for parse() when repairing. Prunes out the unmatched nodes from the tree so we can continue parsing.
+		 * @private
+		 */
 		prune: function(/**BeginEndNode|ContainerNode*/ node, /**Node*/ expected) {
 			var expectedAChild = expected.parent === node;
 			if (expectedAChild) {
@@ -1144,7 +1181,9 @@
 //			// Editor requires StyleRanges must be in ascending order by 'start', or else some will be ignored
 			e.ranges.sort(byStart);
 		},
-		// Run parse algorithm on [start, end] in the context of node, assigning scope as we find matches
+		/** Runs parse algorithm on [start, end] in the context of node, assigning scope as we find matches.
+		 * @private
+		 */
 		getLineScope: function(model, node, start, end) {
 			var pos = start;
 			var expected = this.getInitialExpected(node, start);
@@ -1188,6 +1227,7 @@
 			var inherited = this.getInheritedLineScope(gaps, start, end);
 			return scopes.concat(inherited);
 		},
+		/** @private */
 		getInheritedLineScope: function(gaps, start, end) {
 			var scopes = [];
 			for (var i=0; i < gaps.length; i++) {
@@ -1209,14 +1249,17 @@
 			}
 			return scopes;
 		},
+		/** @private */
 		addBeginScope: function(scopes, match, typedRule) {
 			var rule = typedRule.rule;
 			this.addCapturesScope(scopes, match, (rule.beginCaptures || rule.captures), typedRule.isComplex, typedRule.beginOld2New, typedRule.beginConsuming);
 		},
+		/** @private */
 		addEndScope: function(scopes, match, typedRule) {
 			var rule = typedRule.rule;
 			this.addCapturesScope(scopes, match, (rule.endCaptures || rule.captures), typedRule.isComplex, typedRule.endOld2New, typedRule.endConsuming);
 		},
+		/** @private */
 		addMatchScope: function(scopes, match, typedRule) {
 			var rule = typedRule.rule,
 			    name = rule.name,
@@ -1228,14 +1271,17 @@
 				this.addScope(scopes, match, name);
 			}
 		},
+		/** @private */
 		addScope: function(scopes, match, name) {
 			if (!name) { return; }
 			scopes.push({start: match.index, end: this.afterMatch(match), scope: name });
 		},
+		/** @private */
 		addScopeRange: function(scopes, start, end, name) {
 			if (!name) { return; }
 			scopes.push({start: start, end: end, scope: name });
 		},
+		/** @private */
 		addCapturesScope: function(/**Array*/scopes, /*RegExp.match*/ match, /**Object*/captures, /**Boolean*/isComplex, /**Object*/old2New, /**Object*/consuming) {
 			if (!captures) { return; }
 			if (!isComplex) {
@@ -1269,7 +1315,9 @@
 				}
 			}
 		},
-		/** @returns {Node[]} In depth-first order */
+		/** @returns {Node[]} In depth-first order
+		 * @private
+		 */
 		getIntersecting: function(start, end) {
 			var result = [];
 			var nodes = this._tree ? [this._tree] : [];
@@ -1304,6 +1352,7 @@
 		/**
 		 * Applies the grammar to obtain the {@link eclipse.StyleRange[]} for the given line.
 		 * @returns eclipse.StyleRange[]
+		 * @private
 		 */
 		toStyleRanges: function(/**ScopeRange[]*/ scopeRanges) {
 			var styleRanges = [];
diff --git a/bundles/org.eclipse.orion.client.editor/web/orion/editor/webContentAssist.js b/bundles/org.eclipse.orion.client.editor/web/orion/editor/webContentAssist.js
index 8d83776..d07a3be 100644
--- a/bundles/org.eclipse.orion.client.editor/web/orion/editor/webContentAssist.js
+++ b/bundles/org.eclipse.orion.client.editor/web/orion/editor/webContentAssist.js
@@ -10,25 +10,18 @@
  *******************************************************************************/
 /*global orion:true*/
 
-/** @namespace */
 var orion = orion || {};
 orion.editor = orion.editor || {};
 
 /**
- * @class orion.contentAssist.CssContentAssistProvider
+ * @name orion.contentAssist.CssContentAssistProvider
+ * @class Provides content assist for CSS keywords.
  */
 orion.editor.CssContentAssistProvider = (function() {
 	/** @private */
 	function CssContentAssistProvider() {
 	}
-	CssContentAssistProvider.prototype = /** @lends orion.contentAssist.CssContentAssistProvider.prototype */ {
-		/**
-		 * @param {String} The string buffer.substring(w+1, c) where c is the caret offset and w is the index of the 
-		 * rightmost whitespace character preceding c.
-		 * @param {String} buffer The entire buffer being edited
-		 * @param {orion.editor.Selection} selection The current textView selection.
-		 * @returns {dojo.Deferred} A future that will provide the keywords.
-		 */
+	CssContentAssistProvider.prototype = /** @lends orion.editor.CssContentAssistProvider.prototype */ {
 		getKeywords: function(prefix, buffer, selection) {
 			return [ "background", "background-attachment", "background-color", "background-image",
 					"background-position", "background-repeat", "border", "border-bottom",
@@ -51,20 +44,14 @@
 }());
 
 /**
- * @class orion.contentAssist.JavaScriptContentAssistProvider
+ * @name orion.editor.JavaScriptContentAssistProvider
+ * @class Provides content assist for JavaScript keywords.
  */
 orion.editor.JavaScriptContentAssistProvider = (function() {
 	/** @private */
 	function JavaScriptContentAssistProvider() {
 	}
-	JavaScriptContentAssistProvider.prototype = /** @lends orion.contentAssist.JavaScriptContentAssistProvider.prototype */ {
-		/**
-		 * @param {String} The string buffer.substring(w+1, c) where c is the caret offset and w is the index of the 
-		 * rightmost whitespace character preceding c.
-		 * @param {String} buffer The entire buffer being edited
-		 * @param {orion.editor.Selection} selection The current textView selection.
-		 * @returns {dojo.Deferred} A future that will provide the keywords.
-		 */
+	JavaScriptContentAssistProvider.prototype = /** @lends orion.editor.JavaScriptContentAssistProvider.prototype */ {
 		getKeywords: function(prefix, buffer, selection) {
 			return [ "break", "case", "catch", "continue", "debugger", "default", "delete", "do", "else",
 					"finally", "for", "function", "if", "in", "instanceof", "new", "return", "switch",