DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/components/ObjectPropertiesSection.js

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 46 matching lines @@
 
         var note = this.expandedTitleElement.createChild("span", "object-state-note");
         note.classList.add("info-note");
         note.title = WebInspector.UIString("Value below was evaluated just now.");
     }
 
     this.element._section = this;
     this.registerRequiredCSS("components/objectValue.css");
     this.registerRequiredCSS("components/objectPropertiesSection.css");
     this.rootElement().childrenListElement.classList.add("source-code", "object-properties-section");
-}
+};
 
 /** @const */
 WebInspector.ObjectPropertiesSection._arrayLoadThreshold = 100;
 
 /**
  * @param {!WebInspector.RemoteObject} object
  * @param {!WebInspector.Linkifier=} linkifier
  * @param {boolean=} skipProto
  * @return {!Element}
  */
 WebInspector.ObjectPropertiesSection.defaultObjectPresentation = function(object, linkifier, skipProto)
 {
     var componentRoot = createElementWithClass("span", "source-code");
     var shadowRoot = WebInspector.createShadowRootWithCoreStyles(componentRoot, "components/objectValue.css");
     shadowRoot.appendChild(WebInspector.ObjectPropertiesSection.createValueElement(object, false));
     if (!object.hasChildren)
         return componentRoot;
 
     var objectPropertiesSection = new WebInspector.ObjectPropertiesSection(object, componentRoot, linkifier);
     objectPropertiesSection.editable = false;
     if (skipProto)
         objectPropertiesSection.skipProto();
 
     return objectPropertiesSection.element;
-}
+};
 
 WebInspector.ObjectPropertiesSection.prototype = {
     skipProto: function()
     {
         this._skipProto = true;
     },
 
     expand: function()
     {
         this._objectTreeElement.expand();
@@ skipping 28 matching lines @@
     },
 
     titleLessMode: function()
     {
         this._objectTreeElement.listItemElement.classList.add("hidden");
         this._objectTreeElement.childrenListElement.classList.add("title-less-mode");
         this._objectTreeElement.expand();
     },
 
     __proto__: TreeOutlineInShadow.prototype
-}
+};
 
 /**
  * @param {!WebInspector.RemoteObjectProperty} propertyA
  * @param {!WebInspector.RemoteObjectProperty} propertyB
  * @return {number}
  */
 WebInspector.ObjectPropertiesSection.CompareProperties = function(propertyA, propertyB)
 {
     var a = propertyA.name;
     var b = propertyB.name;
     if (a === "__proto__")
         return 1;
     if (b === "__proto__")
         return -1;
     if (propertyA.symbol && !propertyB.symbol)
         return 1;
     if (propertyB.symbol && !propertyA.symbol)
         return -1;
     return String.naturalOrderComparator(a, b);
-}
+};
 
 /**
  * @constructor
  * @extends {TreeElement}
  * @param {!WebInspector.RemoteObject} object
  * @param {!WebInspector.Linkifier=} linkifier
  * @param {?string=} emptyPlaceholder
  * @param {boolean=} ignoreHasOwnProperty
  * @param {!Array.<!WebInspector.RemoteObjectProperty>=} extraProperties
  */
 WebInspector.ObjectPropertiesSection.RootElement = function(object, linkifier, emptyPlaceholder, ignoreHasOwnProperty, extraProperties)
 {
     this._object = object;
     this._extraProperties = extraProperties || [];
     this._ignoreHasOwnProperty = !!ignoreHasOwnProperty;
     this._emptyPlaceholder = emptyPlaceholder;
     var contentElement = createElement("content");
     TreeElement.call(this, contentElement);
     this.setExpandable(true);
     this.selectable = false;
     this.toggleOnClick = true;
     this.listItemElement.classList.add("object-properties-section-root-element");
     this._linkifier = linkifier;
-}
+};
 
 WebInspector.ObjectPropertiesSection.RootElement.prototype = {
     /**
      * @override
      */
     onexpand: function()
     {
         if (this.treeOutline) {
             this.treeOutline.element.classList.add("expanded");
             this._showExpandedTitleElement(true);
@@ skipping 33 matching lines @@
     {
         return true;
     },
 
     onpopulate: function()
     {
         WebInspector.ObjectPropertyTreeElement._populate(this, this._object, !!this.treeOutline._skipProto, this._linkifier, this._emptyPlaceholder, this._ignoreHasOwnProperty, this._extraProperties);
     },
 
     __proto__: TreeElement.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {TreeElement}
  * @param {!WebInspector.RemoteObjectProperty} property
  * @param {!WebInspector.Linkifier=} linkifier
  */
 WebInspector.ObjectPropertyTreeElement = function(property, linkifier)
 {
     this.property = property;
 
     // Pass an empty title, the title gets made later in onattach.
     TreeElement.call(this);
     this.toggleOnClick = true;
     this.selectable = false;
     /** @type {!Array.<!Object>} */
     this._highlightChanges = [];
     this._linkifier = linkifier;
-}
+};
 
 WebInspector.ObjectPropertyTreeElement.prototype = {
     /**
      * @param {!RegExp} regex
      * @param {string=} additionalCssClassName
      * @return {boolean}
      */
     setSearchRegex: function(regex, additionalCssClassName)
     {
         var cssClasses = WebInspector.highlightedSearchResultClassName;
@@ skipping 303 matching lines @@
 
     _updateExpandable: function()
     {
         if (this.property.value)
             this.setExpandable(!this.property.value.customPreview() && this.property.value.hasChildren && !this.property.wasThrown);
         else
             this.setExpandable(false);
     },
 
     __proto__: TreeElement.prototype
-}
+};
 
 /**
  * @param {!TreeElement} treeElement
  * @param {!WebInspector.RemoteObject} value
  * @param {boolean} skipProto
  * @param {!WebInspector.Linkifier=} linkifier
  * @param {?string=} emptyPlaceholder
  * @param {boolean=} flattenProtoChain
  * @param {!Array.<!WebInspector.RemoteObjectProperty>=} extraProperties
  * @param {!WebInspector.RemoteObject=} targetValue
@@ skipping 21 matching lines @@
             properties.push(extraProperties[i]);
 
         WebInspector.ObjectPropertyTreeElement.populateWithProperties(treeElement, properties, internalProperties,
             skipProto, targetValue || value, linkifier, emptyPlaceholder);
     }
 
     if (flattenProtoChain)
         value.getAllProperties(false, callback);
     else
         WebInspector.RemoteObject.loadFromObjectPerProto(value, callback);
-}
+};
 
 /**
  * @param {!TreeElement} treeNode
  * @param {!Array.<!WebInspector.RemoteObjectProperty>} properties
  * @param {?Array.<!WebInspector.RemoteObjectProperty>} internalProperties
  * @param {boolean} skipProto
  * @param {?WebInspector.RemoteObject} value
  * @param {!WebInspector.Linkifier=} linkifier
  * @param {?string=} emptyPlaceholder
  */
@@ skipping 31 matching lines @@
             internalProperties[i].parentObject = value;
             var treeElement = new WebInspector.ObjectPropertyTreeElement(internalProperties[i], linkifier);
             if (internalProperties[i].name === "[[Entries]]") {
                 treeElement.setExpandable(true);
                 treeElement.expand();
             }
             treeNode.appendChild(treeElement);
         }
     }
     WebInspector.ObjectPropertyTreeElement._appendEmptyPlaceholderIfNeeded(treeNode, emptyPlaceholder);
-}
+};
 
 /**
  * @param {!TreeElement} treeNode
  * @param {?string=} emptyPlaceholder
  */
 WebInspector.ObjectPropertyTreeElement._appendEmptyPlaceholderIfNeeded = function(treeNode, emptyPlaceholder)
 {
     if (treeNode.childCount())
         return;
     var title = createElementWithClass("div", "gray-info-message");
     title.textContent = emptyPlaceholder || WebInspector.UIString("No Properties");
     var infoElement = new TreeElement(title);
     treeNode.appendChild(infoElement);
-}
+};
 
 /**
  * @param {?WebInspector.RemoteObject} object
  * @param {!Array.<string>} propertyPath
  * @param {function(?WebInspector.RemoteObject, boolean=)} callback
  * @return {!Element}
  */
 WebInspector.ObjectPropertyTreeElement.createRemoteObjectAccessorPropertySpan = function(object, propertyPath, callback)
 {
     var rootElement = createElement("span");
     var element = rootElement.createChild("span");
     element.textContent = WebInspector.UIString("(...)");
     if (!object)
         return rootElement;
     element.classList.add("object-value-calculate-value-button");
     element.title = WebInspector.UIString("Invoke property getter");
     element.addEventListener("click", onInvokeGetterClick, false);
 
     function onInvokeGetterClick(event)
     {
         event.consume();
         object.getProperty(propertyPath, callback);
     }
 
     return rootElement;
-}
+};
 
 /**
  * @constructor
  * @extends {TreeElement}
  * @param {!WebInspector.RemoteObject} object
  * @param {number} fromIndex
  * @param {number} toIndex
  * @param {number} propertyCount
  * @param {!WebInspector.Linkifier=} linkifier
  */
 WebInspector.ArrayGroupingTreeElement = function(object, fromIndex, toIndex, propertyCount, linkifier)
 {
     TreeElement.call(this, String.sprintf("[%d \u2026 %d]", fromIndex, toIndex), true);
     this.toggleOnClick = true;
     this.selectable = false;
     this._fromIndex = fromIndex;
     this._toIndex = toIndex;
     this._object = object;
     this._readOnly = true;
     this._propertyCount = propertyCount;
     this._linkifier = linkifier;
-}
+};
 
 WebInspector.ArrayGroupingTreeElement._bucketThreshold = 100;
 WebInspector.ArrayGroupingTreeElement._sparseIterationThreshold = 250000;
 WebInspector.ArrayGroupingTreeElement._getOwnPropertyNamesThreshold = 500000;
 
 /**
  * @param {!TreeElement} treeNode
  * @param {!WebInspector.RemoteObject} object
  * @param {number} fromIndex
  * @param {number} toIndex
  * @param {!WebInspector.Linkifier=} linkifier
  */
 WebInspector.ArrayGroupingTreeElement._populateArray = function(treeNode, object, fromIndex, toIndex, linkifier)
 {
     WebInspector.ArrayGroupingTreeElement._populateRanges(treeNode, object, fromIndex, toIndex, true, linkifier);
-}
+};
 
 /**
  * @param {!TreeElement} treeNode
  * @param {!WebInspector.RemoteObject} object
  * @param {number} fromIndex
  * @param {number} toIndex
  * @param {boolean} topLevel
  * @param {!WebInspector.Linkifier=} linkifier
  * @this {WebInspector.ArrayGroupingTreeElement}
  */
@@ skipping 99 matching lines @@
                 var count = ranges[i][2];
                 if (fromIndex === toIndex)
                     WebInspector.ArrayGroupingTreeElement._populateAsFragment(treeNode, object, fromIndex, toIndex, linkifier);
                 else
                     treeNode.appendChild(new WebInspector.ArrayGroupingTreeElement(object, fromIndex, toIndex, count, linkifier));
             }
         }
         if (topLevel)
             WebInspector.ArrayGroupingTreeElement._populateNonIndexProperties(treeNode, object, result.skipGetOwnPropertyNames, linkifier);
     }
-}
+};
 
 /**
  * @param {!TreeElement} treeNode
  * @param {!WebInspector.RemoteObject} object
  * @param {number} fromIndex
  * @param {number} toIndex
  * @param {!WebInspector.Linkifier=} linkifier
  * @this {WebInspector.ArrayGroupingTreeElement}
  */
 WebInspector.ArrayGroupingTreeElement._populateAsFragment = function(treeNode, object, fromIndex, toIndex, linkifier)
@@ skipping 46 matching lines @@
             return;
 
         properties.sort(WebInspector.ObjectPropertiesSection.CompareProperties);
         for (var i = 0; i < properties.length; ++i) {
             properties[i].parentObject = this._object;
             var childTreeElement = new WebInspector.ObjectPropertyTreeElement(properties[i], linkifier);
             childTreeElement._readOnly = true;
             treeNode.appendChild(childTreeElement);
         }
     }
-}
+};
 
 /**
  * @param {!TreeElement} treeNode
  * @param {!WebInspector.RemoteObject} object
  * @param {boolean} skipGetOwnPropertyNames
  * @param {!WebInspector.Linkifier=} linkifier
  * @this {WebInspector.ArrayGroupingTreeElement}
  */
 WebInspector.ArrayGroupingTreeElement._populateNonIndexProperties = function(treeNode, object, skipGetOwnPropertyNames, linkifier)
 {
@@ skipping 44 matching lines @@
         if (!properties)
             return;
         properties.sort(WebInspector.ObjectPropertiesSection.CompareProperties);
         for (var i = 0; i < properties.length; ++i) {
             properties[i].parentObject = this._object;
             var childTreeElement = new WebInspector.ObjectPropertyTreeElement(properties[i], linkifier);
             childTreeElement._readOnly = true;
             treeNode.appendChild(childTreeElement);
         }
     }
-}
+};
 
 WebInspector.ArrayGroupingTreeElement.prototype = {
     onpopulate: function()
     {
         if (this._propertyCount >= WebInspector.ArrayGroupingTreeElement._bucketThreshold) {
             WebInspector.ArrayGroupingTreeElement._populateRanges(this, this._object, this._fromIndex, this._toIndex, false, this._linkifier);
             return;
         }
         WebInspector.ArrayGroupingTreeElement._populateAsFragment(this, this._object, this._fromIndex, this._toIndex, this._linkifier);
     },
 
     onattach: function()
     {
         this.listItemElement.classList.add("object-properties-section-name");
     },
 
     __proto__: TreeElement.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.TextPrompt}
  */
 WebInspector.ObjectPropertyPrompt = function()
 {
     WebInspector.TextPrompt.call(this, WebInspector.ExecutionContextSelector.completionsForTextPromptInCurrentContext);
     this.setSuggestBoxEnabled(true);
-}
+};
 
 WebInspector.ObjectPropertyPrompt.prototype = {
     __proto__: WebInspector.TextPrompt.prototype
-}
+};
 
 /**
  * @param {?string} name
  * @return {!Element}
  */
 WebInspector.ObjectPropertiesSection.createNameElement = function(name)
 {
     var nameElement = createElementWithClass("span", "name");
     if (/^\s|\s$|^$|\n/.test(name))
         nameElement.createTextChildren("\"", name.replace(/\n/g, "\u21B5"), "\"");
     else
         nameElement.textContent = name;
     return nameElement;
-}
+};
 
 WebInspector.ObjectPropertiesSection._functionPrefixSource = /^(?:async\s)?function\*?\s/;
 
 /**
  * @param {?string=} description
  * @return {string} valueText
  */
 WebInspector.ObjectPropertiesSection.valueTextForFunctionDescription = function(description)
 {
     var text = description.replace(/^function [gs]et /, "function ");
     var functionPrefixWithArguments = new RegExp(WebInspector.ObjectPropertiesSection._functionPrefixSource.source + "([^)]*)");
     var matches = functionPrefixWithArguments.exec(text);
     if (!matches) {
         // process shorthand methods
         matches = /[^(]*(\([^)]*)/.exec(text);
     }
     var match = matches ? matches[1] : null;
     return match ? match.replace(/\n/g, " ") + ")" : (text || "");
-}
+};
 
 /**
  * @param {!WebInspector.RemoteObject} value
  * @param {boolean} wasThrown
  * @param {!Element=} parentElement
  * @param {!WebInspector.Linkifier=} linkifier
  * @return {!Element}
  */
 WebInspector.ObjectPropertiesSection.createValueElementWithCustomSupport = function(value, wasThrown, parentElement, linkifier)
 {
     if (value.customPreview()) {
         var result = (new WebInspector.CustomPreviewComponent(value)).element;
         result.classList.add("object-properties-section-custom-section");
-        return result
+        return result;
     }
     return WebInspector.ObjectPropertiesSection.createValueElement(value, wasThrown, parentElement, linkifier);
-}
+};
 
 /**
  * @param {!WebInspector.RemoteObject} value
  * @param {boolean} wasThrown
  * @param {!Element=} parentElement
  * @param {!WebInspector.Linkifier=} linkifier
  * @return {!Element}
  */
 WebInspector.ObjectPropertiesSection.createValueElement = function(value, wasThrown, parentElement, linkifier)
 {
@@ skipping 69 matching lines @@
     /**
      * @param {!Event} event
      */
     function mouseClick(event)
     {
         WebInspector.Revealer.reveal(value);
         event.consume(true);
     }
 
     return valueElement;
-}
+};
 
 /**
  * @param {!WebInspector.RemoteObject} object
  * @return {boolean}
  */
 WebInspector.ObjectPropertiesSection._needsAlternateTitle = function(object)
 {
     return object && object.hasChildren && !object.customPreview() && object.subtype !== "node" && object.type !== "function" && (object.type !== "object" || object.preview);
-}
+};
 
 /**
  * @param {!WebInspector.RemoteObject} func
  * @param {!Element} element
  * @param {boolean} linkify
  * @param {boolean=} includePreview
  */
 WebInspector.ObjectPropertiesSection.formatObjectAsFunction = function(func, element, linkify, includePreview)
 {
     func.debuggerModel().functionDetailsPromise(func).then(didGetDetails);
@@ skipping 62 matching lines @@
             if (doneProcessing)
                 return;
             if (token === "(") {
                 params = [];
                 return;
             }
             if (params && tokenType === "js-def")
                 params.push(token);
         }
     }
-}
+};
 
 /**
  * @constructor
  */
 WebInspector.ObjectPropertiesSectionExpandController = function()
 {
     /** @type {!Set.<string>} */
     this._expandedProperties = new Set();
-}
+};
 
 WebInspector.ObjectPropertiesSectionExpandController._cachedPathSymbol = Symbol("cachedPath");
 WebInspector.ObjectPropertiesSectionExpandController._treeOutlineId = Symbol("treeOutlineId");
 
 WebInspector.ObjectPropertiesSectionExpandController.prototype = {
     /**
      * @param {string} id
      * @param {!WebInspector.ObjectPropertiesSection} section
      */
     watchSection: function(id, section)
@@ skipping 69 matching lines @@
                 currentName = typeof current.title === "string" ? current.title : current.title.textContent;
 
             result = currentName + (result ? "." + result : "");
             current = current.parent;
         }
         var treeOutlineId = treeElement.treeOutline[WebInspector.ObjectPropertiesSectionExpandController._treeOutlineId];
         result = treeOutlineId + (result ? ":" + result : "");
         treeElement[WebInspector.ObjectPropertiesSectionExpandController._cachedPathSymbol] = result;
         return result;
     }
-}
+};