DevTools: use semicolons after each statement.

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

 // Copyright 2016 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.
 
 /**
  * @constructor
  * @param {!WebInspector.ASTService} astService
  * @param {!WebInspector.ASTSourceMap} map
  * @param {!Array<!WebInspector.SASSProcessor.EditOperation>} editOperations
  */
 WebInspector.SASSProcessor = function(astService, map, editOperations)
 {
     this._astService = astService;
     this._map = map;
     this._editOperations = editOperations;
-}
+};
 
 WebInspector.SASSProcessor.prototype = {
     /**
      * @return {!Promise<?WebInspector.SourceMap.EditResult>}
      */
     _mutate: function()
     {
         /** @type {!Set<!WebInspector.SASSSupport.Rule>} */
         var changedCSSRules = new Set();
         for (var editOperation of this._editOperations) {
@@ skipping 40 matching lines @@
 
         /** @type {!Map<string, string>} */
         var newSASSSources = new Map();
         for (var model of changedModels) {
             if (model.document.url === map.compiledURL())
                 continue;
             newSASSSources.set(model.document.url, model.document.text.value());
         }
         return new WebInspector.SourceMap.EditResult(map, cssEdits, newSASSSources);
     }
-}
+};
 
 /**
  * @param {!WebInspector.ASTSourceMap} map
  * @param {!WebInspector.SASSSupport.Property} cssProperty
  * @return {?WebInspector.SASSSupport.Property}
  */
 WebInspector.SASSProcessor._toSASSProperty = function(map, cssProperty)
 {
     var sassName = map.toSourceNode(cssProperty.name);
     return sassName ? sassName.parent : null;
-}
+};
 
 /**
  * @param {!WebInspector.ASTSourceMap} map
  * @param {!WebInspector.SASSSupport.Property} sassProperty
  * @return {!Array<!WebInspector.SASSSupport.Property>}
  */
 WebInspector.SASSProcessor._toCSSProperties = function(map, sassProperty)
 {
     return map.toCompiledNodes(sassProperty.name).map(name => name.parent);
-}
+};
 
 /**
  * @param {!WebInspector.ASTService} astService
  * @param {!WebInspector.ASTSourceMap} map
  * @param {!Array<!WebInspector.TextRange>} ranges
  * @param {!Array<string>} newTexts
  * @return {!Promise<?WebInspector.SourceMap.EditResult>}
  */
 WebInspector.SASSProcessor.processCSSEdits = function(astService, map, ranges, newTexts)
 {
@@ skipping 25 matching lines @@
             clonedModels.push(map.modelForURL(url).clone());
 
         // Rebase map and edits onto a cloned AST trees.
         var nodeMapping = new Map();
         var rebasedMap = /** @type {!WebInspector.ASTSourceMap} */(map.rebase(clonedModels, nodeMapping));
         console.assert(rebasedMap);
         var rebasedEdits = edits.map(edit => edit.rebase(rebasedMap, nodeMapping));
 
         return new WebInspector.SASSProcessor(astService, rebasedMap, rebasedEdits)._mutate();
     }
-}
+};
 
 /**
  * @param {!WebInspector.SASSSupport.ASTDiff} cssDiff
  * @param {!WebInspector.ASTSourceMap} map
  * @return {!Array<!WebInspector.SASSProcessor.EditOperation>}
  */
 WebInspector.SASSProcessor._editsFromCSSDiff = function(cssDiff, map)
 {
     var T = WebInspector.SASSSupport.PropertyChangeType;
     var operations = [];
@@ skipping 13 matching lines @@
             continue;
         }
 
         var merged = false;
         for (var j = 0; !merged && j < operations.length; ++j)
             merged = operations[j].merge(operation);
         if (!merged)
             operations.push(operation);
     }
     return operations;
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.ASTSourceMap} map
  * @param {string} sassURL
  */
 WebInspector.SASSProcessor.EditOperation = function(map, sassURL)
 {
     this.map = map;
     this.sassURL = sassURL;
-}
+};
 
 WebInspector.SASSProcessor.EditOperation.prototype = {
     /**
      * @param {!WebInspector.SASSProcessor.EditOperation} other
      * @return {boolean}
      */
     merge: function(other)
     {
         return false;
     },
 
     /**
      * @return {!Array<!WebInspector.SASSSupport.Rule>}
      */
     perform: function()
     {
         return [];
     },
 
     /**
      * @param {!WebInspector.ASTSourceMap} newMap
      * @param {!Map<!WebInspector.SASSSupport.Node, !WebInspector.SASSSupport.Node>} nodeMapping
      * @return {!WebInspector.SASSProcessor.EditOperation}
      */
     rebase: function(newMap, nodeMapping)
     {
         return this;
     },
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.SASSProcessor.EditOperation}
  * @param {!WebInspector.ASTSourceMap} map
  * @param {!WebInspector.SASSSupport.TextNode} sassNode
  * @param {string} newText
  */
 WebInspector.SASSProcessor.SetTextOperation = function(map, sassNode, newText)
 {
     WebInspector.SASSProcessor.EditOperation.call(this, map, sassNode.document.url);
     this._sassNode = sassNode;
     this._newText = newText;
-}
+};
 
 /**
  * @param {!WebInspector.SASSSupport.PropertyChange} change
  * @param {!WebInspector.ASTSourceMap} map
  * @return {?WebInspector.SASSProcessor.SetTextOperation}
  */
 WebInspector.SASSProcessor.SetTextOperation.fromCSSChange = function(change, map)
 {
     var oldProperty = /** @type {!WebInspector.SASSSupport.Property} */(change.oldProperty());
     var newProperty = /** @type {!WebInspector.SASSSupport.Property} */(change.newProperty());
     console.assert(oldProperty && newProperty, "SetTextOperation must have both oldProperty and newProperty");
     var newValue = null;
     var sassNode = null;
     if (change.type === WebInspector.SASSSupport.PropertyChangeType.NameChanged) {
         newValue = newProperty.name.text;
         sassNode = map.toSourceNode(oldProperty.name);
     } else {
         newValue = newProperty.value.text;
         sassNode = map.toSourceNode(oldProperty.value);
     }
     if (!sassNode)
         return null;
     return new WebInspector.SASSProcessor.SetTextOperation(map, sassNode, newValue);
-}
+};
 
 WebInspector.SASSProcessor.SetTextOperation.prototype = {
     /**
      * @override
      * @param {!WebInspector.SASSProcessor.EditOperation} other
      * @return {boolean}
      */
     merge: function(other)
     {
         if (!(other instanceof WebInspector.SASSProcessor.SetTextOperation))
@@ skipping 22 matching lines @@
      * @param {!Map<!WebInspector.SASSSupport.Node, !WebInspector.SASSSupport.Node>} nodeMapping
      * @return {!WebInspector.SASSProcessor.SetTextOperation}
      */
     rebase: function(newMap, nodeMapping)
     {
         var sassNode = /** @type {?WebInspector.SASSSupport.TextNode} */(nodeMapping.get(this._sassNode)) || this._sassNode;
         return new WebInspector.SASSProcessor.SetTextOperation(newMap, sassNode, this._newText);
     },
 
     __proto__: WebInspector.SASSProcessor.EditOperation.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.SASSProcessor.EditOperation}
  * @param {!WebInspector.ASTSourceMap} map
  * @param {!WebInspector.SASSSupport.Property} sassProperty
  * @param {boolean} newDisabled
  */
 WebInspector.SASSProcessor.TogglePropertyOperation = function(map, sassProperty, newDisabled)
 {
     WebInspector.SASSProcessor.EditOperation.call(this, map, sassProperty.document.url);
     this._sassProperty = sassProperty;
     this._newDisabled = newDisabled;
-}
+};
 
 /**
  * @param {!WebInspector.SASSSupport.PropertyChange} change
  * @param {!WebInspector.ASTSourceMap} map
  * @return {?WebInspector.SASSProcessor.TogglePropertyOperation}
  */
 WebInspector.SASSProcessor.TogglePropertyOperation.fromCSSChange = function(change, map)
 {
     var oldCSSProperty = /** @type {!WebInspector.SASSSupport.Property} */(change.oldProperty());
     console.assert(oldCSSProperty, "TogglePropertyOperation must have old CSS property");
     var sassProperty = WebInspector.SASSProcessor._toSASSProperty(map, oldCSSProperty);
     if (!sassProperty)
         return null;
     var newDisabled = change.newProperty().disabled;
     return new WebInspector.SASSProcessor.TogglePropertyOperation(map, sassProperty, newDisabled);
-}
+};
 
 WebInspector.SASSProcessor.TogglePropertyOperation.prototype = {
     /**
      * @override
      * @param {!WebInspector.SASSProcessor.EditOperation} other
      * @return {boolean}
      */
     merge: function(other)
     {
         if (!(other instanceof WebInspector.SASSProcessor.TogglePropertyOperation))
@@ skipping 22 matching lines @@
      * @param {!Map<!WebInspector.SASSSupport.Node, !WebInspector.SASSSupport.Node>} nodeMapping
      * @return {!WebInspector.SASSProcessor.TogglePropertyOperation}
      */
     rebase: function(newMap, nodeMapping)
     {
         var sassProperty = /** @type {?WebInspector.SASSSupport.Property} */(nodeMapping.get(this._sassProperty)) || this._sassProperty;
         return new WebInspector.SASSProcessor.TogglePropertyOperation(newMap, sassProperty, this._newDisabled);
     },
 
     __proto__: WebInspector.SASSProcessor.EditOperation.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.SASSProcessor.EditOperation}
  * @param {!WebInspector.ASTSourceMap} map
  * @param {!WebInspector.SASSSupport.Property} sassProperty
  */
 WebInspector.SASSProcessor.RemovePropertyOperation = function(map, sassProperty)
 {
     WebInspector.SASSProcessor.EditOperation.call(this, map, sassProperty.document.url);
     this._sassProperty = sassProperty;
-}
+};
 
 /**
  * @param {!WebInspector.SASSSupport.PropertyChange} change
  * @param {!WebInspector.ASTSourceMap} map
  * @return {?WebInspector.SASSProcessor.RemovePropertyOperation}
  */
 WebInspector.SASSProcessor.RemovePropertyOperation.fromCSSChange = function(change, map)
 {
     var removedProperty = /** @type {!WebInspector.SASSSupport.Property} */(change.oldProperty());
     console.assert(removedProperty, "RemovePropertyOperation must have removed CSS property");
     var sassProperty = WebInspector.SASSProcessor._toSASSProperty(map, removedProperty);
     if (!sassProperty)
         return null;
     return new WebInspector.SASSProcessor.RemovePropertyOperation(map, sassProperty);
-}
+};
 
 WebInspector.SASSProcessor.RemovePropertyOperation.prototype = {
     /**
      * @override
      * @param {!WebInspector.SASSProcessor.EditOperation} other
      * @return {boolean}
      */
     merge: function(other)
     {
         if (!(other instanceof WebInspector.SASSProcessor.RemovePropertyOperation))
@@ skipping 25 matching lines @@
      * @param {!Map<!WebInspector.SASSSupport.Node, !WebInspector.SASSSupport.Node>} nodeMapping
      * @return {!WebInspector.SASSProcessor.RemovePropertyOperation}
      */
     rebase: function(newMap, nodeMapping)
     {
         var sassProperty = /** @type {?WebInspector.SASSSupport.Property} */(nodeMapping.get(this._sassProperty)) || this._sassProperty;
         return new WebInspector.SASSProcessor.RemovePropertyOperation(newMap, sassProperty);
     },
 
     __proto__: WebInspector.SASSProcessor.EditOperation.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.SASSProcessor.EditOperation}
  * @param {!WebInspector.ASTSourceMap} map
  * @param {!WebInspector.SASSSupport.Rule} sassRule
  * @param {?WebInspector.SASSSupport.Property} afterSASSProperty
  * @param {!Array<string>} propertyNames
  * @param {!Array<string>} propertyValues
  * @param {!Array<boolean>} disabledStates
  */
 WebInspector.SASSProcessor.InsertPropertiesOperation = function(map, sassRule, afterSASSProperty, propertyNames, propertyValues, disabledStates)
 {
     console.assert(propertyNames.length === propertyValues.length && propertyValues.length === disabledStates.length);
     WebInspector.SASSProcessor.EditOperation.call(this, map, sassRule.document.url);
     this._sassRule = sassRule;
-    this._afterSASSProperty = afterSASSProperty
+    this._afterSASSProperty = afterSASSProperty;
     this._nameTexts = propertyNames;
     this._valueTexts = propertyValues;
     this._disabledStates = disabledStates;
-}
+};
 
 /**
  * @param {!WebInspector.SASSSupport.PropertyChange} change
  * @param {!WebInspector.ASTSourceMap} map
  * @return {?WebInspector.SASSProcessor.InsertPropertiesOperation}
  */
 WebInspector.SASSProcessor.InsertPropertiesOperation.fromCSSChange = function(change, map)
 {
     var sassRule = null;
     var afterSASSProperty = null;
     if (change.oldPropertyIndex) {
         var cssAnchor = change.oldRule.properties[change.oldPropertyIndex - 1].name;
         var sassAnchor = map.toSourceNode(cssAnchor);
         afterSASSProperty = sassAnchor ? sassAnchor.parent : null;
         sassRule = afterSASSProperty ? afterSASSProperty.parent : null;
     } else {
         var cssAnchor = change.oldRule.blockStart;
         var sassAnchor = map.toSourceNode(cssAnchor);
         sassRule = sassAnchor ? sassAnchor.parent : null;
     }
     if (!sassRule)
         return null;
     var insertedProperty = /** @type {!WebInspector.SASSSupport.Property} */(change.newProperty());
     console.assert(insertedProperty, "InsertPropertiesOperation must have inserted CSS property");
     var names = [insertedProperty.name.text];
     var values = [insertedProperty.value.text];
     var disabledStates = [insertedProperty.disabled];
     return new WebInspector.SASSProcessor.InsertPropertiesOperation(map, sassRule, afterSASSProperty, names, values, disabledStates);
-}
+};
 
 WebInspector.SASSProcessor.InsertPropertiesOperation.prototype = {
     /**
      * @override
      * @param {!WebInspector.SASSProcessor.EditOperation} other
      * @return {boolean}
      */
     merge: function(other)
     {
         if (!(other instanceof WebInspector.SASSProcessor.InsertPropertiesOperation))
@@ skipping 46 matching lines @@
      * @return {!WebInspector.SASSProcessor.InsertPropertiesOperation}
      */
     rebase: function(newMap, nodeMapping)
     {
         var sassRule = /** @type {?WebInspector.SASSSupport.Rule} */(nodeMapping.get(this._sassRule)) || this._sassRule;
         var afterSASSProperty = this._afterSASSProperty ? /** @type {?WebInspector.SASSSupport.Property} */(nodeMapping.get(this._afterSASSProperty)) || this._afterSASSProperty : null;
         return new WebInspector.SASSProcessor.InsertPropertiesOperation(newMap, sassRule, afterSASSProperty, this._nameTexts, this._valueTexts, this._disabledStates);
     },
 
     __proto__: WebInspector.SASSProcessor.EditOperation.prototype
-}
+};