DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/sass/SASSSupport.js

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-WebInspector.SASSSupport = {}
+WebInspector.SASSSupport = {};
 
 /**
  * @param {string} url
  * @param {string} content
  * @return {!Promise<!WebInspector.SASSSupport.AST>}
  */
 WebInspector.SASSSupport.parseSCSS = function(url, content)
 {
     var text = new WebInspector.Text(content);
     var document = new WebInspector.SASSSupport.ASTDocument(url, text);
@@ skipping 33 matching lines @@
 
     /**
      * @param {!Object} payload
      */
     function createProperty(payload)
     {
         var name = createTextNode(payload.name);
         var value = createTextNode(payload.value);
         return new WebInspector.SASSSupport.Property(document, name, value, WebInspector.TextRange.fromObject(payload.range), payload.disabled);
     }
-}
+};
 
 /**
  * @constructor
  * @param {string} url
  * @param {!WebInspector.Text} text
  */
 WebInspector.SASSSupport.ASTDocument = function(url, text)
 {
     this.url = url;
     this.text = text;
     this.edits = [];
-}
+};
 
 WebInspector.SASSSupport.ASTDocument.prototype = {
     /**
      * @return {!WebInspector.SASSSupport.ASTDocument}
      */
     clone: function()
     {
         return new WebInspector.SASSSupport.ASTDocument(this.url, this.text);
     },
 
@@ skipping 26 matching lines @@
          */
         function sequentialOrder(edit1, edit2)
         {
             var range1 = edit1.oldRange.collapseToStart();
             var range2 = edit2.oldRange.collapseToStart();
             if (range1.equal(range2))
                 return 0;
             return range1.follows(range2) ? 1 : -1;
         }
     },
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.SASSSupport.ASTDocument} document
  */
 WebInspector.SASSSupport.Node = function(document)
 {
     this.document = document;
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.SASSSupport.Node}
  * @param {!WebInspector.SASSSupport.ASTDocument} document
  * @param {string} text
  * @param {!WebInspector.TextRange} range
  */
 WebInspector.SASSSupport.TextNode = function(document, text, range)
 {
     WebInspector.SASSSupport.Node.call(this, document);
     this.text = text;
     this.range = range;
-}
+};
 
 WebInspector.SASSSupport.TextNode.prototype = {
     /**
      * @param {string} newText
      */
     setText: function(newText)
     {
         if (this.text === newText)
             return;
         this.text = newText;
@@ skipping 17 matching lines @@
     match: function(other, outNodeMapping)
     {
         if (this.text.trim() !== other.text.trim())
             return false;
         if (outNodeMapping)
             outNodeMapping.set(this, other);
         return true;
     },
 
     __proto__: WebInspector.SASSSupport.Node.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.SASSSupport.Node}
  * @param {!WebInspector.SASSSupport.ASTDocument} document
  * @param {!WebInspector.SASSSupport.TextNode} name
  * @param {!WebInspector.SASSSupport.TextNode} value
  * @param {!WebInspector.TextRange} range
  * @param {boolean} disabled
  */
 WebInspector.SASSSupport.Property = function(document, name, value, range, disabled)
 {
     WebInspector.SASSSupport.Node.call(this, document);
     this.name = name;
     this.value = value;
     this.range = range;
     this.name.parent = this;
     this.value.parent = this;
     this.disabled = disabled;
-}
+};
 
 WebInspector.SASSSupport.Property.prototype = {
     /**
      * @param {!WebInspector.SASSSupport.ASTDocument} document
      * @return {!WebInspector.SASSSupport.Property}
      */
     clone: function(document)
     {
         return new WebInspector.SASSSupport.Property(document, this.name.clone(document), this.value.clone(document), this.range.clone(), this.disabled);
     },
@@ skipping 59 matching lines @@
         var lineRange = new WebInspector.TextRange(this.range.startLine, 0, this.range.endLine + 1, 0);
         var oldRange;
         if (this.document.text.extract(lineRange).trim() === this.document.text.extract(this.range).trim())
             oldRange = lineRange;
         else
             oldRange = this.range;
         this.document.edits.push(new WebInspector.SourceEdit(this.document.url, oldRange, ""));
     },
 
     __proto__: WebInspector.SASSSupport.Node.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.SASSSupport.Node}
  * @param {!WebInspector.SASSSupport.ASTDocument} document
  * @param {!Array<!WebInspector.SASSSupport.TextNode>} selectors
  * @param {!WebInspector.TextRange} styleRange
  * @param {!Array<!WebInspector.SASSSupport.Property>} properties
  */
 WebInspector.SASSSupport.Rule = function(document, selectors, styleRange, properties)
 {
     WebInspector.SASSSupport.Node.call(this, document);
     this.selectors = selectors;
     this.properties = properties;
     this.styleRange = styleRange;
 
     var blockStartRange = styleRange.collapseToStart();
     blockStartRange.startColumn -= 1;
     this.blockStart = new WebInspector.SASSSupport.TextNode(document, this.document.text.extract(blockStartRange), blockStartRange);
     this.blockStart.parent = this;
 
     for (var i = 0; i < this.properties.length; ++i)
         this.properties[i].parent = this;
 
     this._hasTrailingSemicolon = !this.properties.length || this.document.text.extract(this.properties.peekLast().range).endsWith(";");
-}
+};
 
 WebInspector.SASSSupport.Rule.prototype = {
     /**
      * @param {!WebInspector.SASSSupport.ASTDocument} document
      * @return {!WebInspector.SASSSupport.Rule}
      */
     clone: function(document)
     {
         var properties = [];
         for (var i = 0; i < this.properties.length; ++i)
@@ skipping 36 matching lines @@
         for (var i = 0; result && i < this.properties.length; ++i)
             result = result && this.properties[i].match(other.properties[i], outNodeMapping);
         return result;
     },
 
     _addTrailingSemicolon: function()
     {
         if (this._hasTrailingSemicolon || !this.properties)
             return;
         this._hasTrailingSemicolon = true;
-        this.document.edits.push(new WebInspector.SourceEdit(this.document.url, this.properties.peekLast().range.collapseToEnd(), ";"))
+        this.document.edits.push(new WebInspector.SourceEdit(this.document.url, this.properties.peekLast().range.collapseToEnd(), ";"));
     },
 
     /**
      * @param {?WebInspector.SASSSupport.Property} anchorProperty
      * @param {!Array<string>} nameTexts
      * @param {!Array<string>} valueTexts
      * @param {!Array<boolean>} disabledStates
      * @return {!Array<!WebInspector.SASSSupport.Property>}
      */
     insertProperties: function(anchorProperty, nameTexts, valueTexts, disabledStates)
@@ skipping 49 matching lines @@
         } else {
             var lineNumber = this.blockStart.range.startLine;
             var columnNumber = this.blockStart.range.startColumn;
             var baseLine = this.document.text.extract(new WebInspector.TextRange(lineNumber, 0, lineNumber, columnNumber));
             result = WebInspector.TextUtils.lineIndent(baseLine) + WebInspector.moduleSetting("textEditorIndent").get();
         }
         return result.isWhitespace() ? result : "";
     },
 
     __proto__: WebInspector.SASSSupport.Node.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.SASSSupport.Node}
  * @param {!WebInspector.SASSSupport.ASTDocument} document
  * @param {!Array<!WebInspector.SASSSupport.Rule>} rules
  */
 WebInspector.SASSSupport.AST = function(document, rules)
 {
     WebInspector.SASSSupport.Node.call(this, document);
     this.rules = rules;
     for (var i = 0; i < rules.length; ++i)
         rules[i].parent = this;
-}
+};
 
 WebInspector.SASSSupport.AST.prototype = {
     /**
      * @return {!WebInspector.SASSSupport.AST}
      */
     clone: function()
     {
         var document = this.document.clone();
         var rules = [];
         for (var i = 0; i < this.rules.length; ++i)
@@ skipping 79 matching lines @@
          * @param {!WebInspector.SASSSupport.TextNode} text2
          * @return {number}
          */
         function nodeComparator(text1, text2)
         {
             return WebInspector.TextRange.comparator(text1.range, text2.range);
         }
     },
 
     __proto__: WebInspector.SASSSupport.Node.prototype
-}
+};
 
 /** @enum {string} */
 WebInspector.SASSSupport.PropertyChangeType = {
     PropertyAdded: "PropertyAdded",
     PropertyRemoved: "PropertyRemoved",
     PropertyToggled: "PropertyToggled",
     ValueChanged: "ValueChanged",
     NameChanged: "NameChanged"
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.SASSSupport.PropertyChangeType} type
  * @param {!WebInspector.SASSSupport.Rule} oldRule
  * @param {!WebInspector.SASSSupport.Rule} newRule
  * @param {number} oldPropertyIndex
  * @param {number} newPropertyIndex
  */
 WebInspector.SASSSupport.PropertyChange = function(type, oldRule, newRule, oldPropertyIndex, newPropertyIndex)
 {
     this.type = type;
     this.oldRule = oldRule;
     this.newRule = newRule;
     this.oldPropertyIndex = oldPropertyIndex;
     this.newPropertyIndex = newPropertyIndex;
-}
+};
 
 WebInspector.SASSSupport.PropertyChange.prototype = {
     /**
      * @return {?WebInspector.SASSSupport.Property}
      */
     oldProperty: function()
     {
         return this.oldRule.properties[this.oldPropertyIndex] || null;
     },
 
     /**
      * @return {?WebInspector.SASSSupport.Property}
      */
     newProperty: function()
     {
         return this.newRule.properties[this.newPropertyIndex] || null;
     }
-}
+};
 
 /**
  * @constructor
  * @param {string} url
  * @param {!WebInspector.SASSSupport.AST} oldAST
  * @param {!WebInspector.SASSSupport.AST} newAST
  * @param {!Map<!WebInspector.SASSSupport.TextNode, !WebInspector.SASSSupport.TextNode>} mapping
  * @param {!Array<!WebInspector.SASSSupport.PropertyChange>} changes
  */
 WebInspector.SASSSupport.ASTDiff = function(url, oldAST, newAST, mapping, changes)
 {
     this.url = url;
     this.mapping = mapping;
     this.changes = changes;
     this.oldAST = oldAST;
     this.newAST = newAST;
-}
+};
 
 /**
  * @param {!WebInspector.SASSSupport.AST} oldAST
  * @param {!WebInspector.SASSSupport.AST} newAST
  * @return {!WebInspector.SASSSupport.ASTDiff}
  */
 WebInspector.SASSSupport.diffModels = function(oldAST, newAST)
 {
     console.assert(oldAST.rules.length === newAST.rules.length, "Not implemented for rule diff.");
     console.assert(oldAST.document.url === newAST.document.url, "Diff makes sense for models with the same url.");
@@ skipping 65 matching lines @@
         var newProperty = newRule.properties[newPropertyIndex];
         mapping.set(oldProperty.name, newProperty.name);
         mapping.set(oldProperty.value, newProperty.value);
         if (oldProperty.name.text.trim() !== newProperty.name.text.trim())
             addChange(T.NameChanged, oldRule, newRule, oldPropertyIndex, newPropertyIndex);
         if (oldProperty.value.text.trim() !== newProperty.value.text.trim())
             addChange(T.ValueChanged, oldRule, newRule, oldPropertyIndex, newPropertyIndex);
         if (oldProperty.disabled !== newProperty.disabled)
             addChange(T.PropertyToggled, oldRule, newRule, oldPropertyIndex, newPropertyIndex);
     }
-}
+};