More style fixes.

wheerd · wheerd · commit 28b699a8927b · 2017-02-20T17:07:07.000+01:00
diff --git a/Sources/ast.swift b/Sources/ast.swift
@@ -1,4 +1,5 @@
 protocol ASTNode: CustomStringConvertible {
+
 }
 
 protocol Statement: ASTNode {
@@ -24,6 +25,7 @@ protocol Declaration: ASTNode {
 }
 
 class BaseDeclaration: Declaration {
+
     let name: String
 
     init(_ name: String) {
@@ -35,6 +37,7 @@ class BaseDeclaration: Declaration {
             preconditionFailure("This method must be overridden")
         }
     }
+
 }
 
 protocol OperatorDeclaration: Declaration {
@@ -58,6 +61,7 @@ class PostfixOperatorDeclaration: BaseDeclaration, OperatorDeclaration {
 }
 
 class InfixOperatorDeclaration: BaseDeclaration, OperatorDeclaration {
+
     let precedenceGroupName: String?
 
     init(_ name: String, precedenceGroup: String? = nil) {
@@ -71,13 +75,15 @@ class InfixOperatorDeclaration: BaseDeclaration, OperatorDeclaration {
         }
         return "infix operator \(name)"
     }
+
 }
 
 enum Associativity {
     case Left, Right, None
 }
 
 class PrecedenceGroupDeclaration: BaseDeclaration {
+
     let `higherThan`: [Identifier]
     let `lowerThan`: [Identifier]
     let `associativity`: Associativity
diff --git a/Sources/diagnostics.swift b/Sources/diagnostics.swift
@@ -104,10 +104,10 @@ class Diagnose: Error, CustomStringConvertible {
         description += "^" * max(count, 1)
         if !fixIts.isEmpty {
             description += "\n\nFix:\n"
-            description += fixIts.map{String(describing: $0)}.joined(separator: "\n")
+            description += fixIts.map { String(describing: $0) }.joined(separator: "\n")
         }
         if !related.isEmpty {
-            description += "\n\n" + related.map{String(describing: $0)}.joined(separator: "\n")
+            description += "\n\n" + related.map { String(describing: $0) }.joined(separator: "\n")
         }
         return description
     }
diff --git a/Sources/helpers.swift b/Sources/helpers.swift
@@ -199,11 +199,11 @@ extension String {
         return self.characters.count
     }
 
-    subscript (i: Int) -> Character {
+    subscript(i: Int) -> Character {
         return self.characters[index(startIndex, offsetBy: i)]
     }
 
-    subscript (range: Range<Int>) -> String {
+    subscript(range: Range<Int>) -> String {
         let startOffset = clamp(range.lowerBound, lower: 0, upper: length)
         let endOffset = clamp(range.upperBound, lower: 0, upper: length)
         let start = index(startIndex, offsetBy: startOffset)
diff --git a/Sources/lexer.swift b/Sources/lexer.swift
@@ -540,7 +540,7 @@ class Lexer: Sequence {
                 break
         }
 
-        let type: TokenTypev = leftBound == rightBound ? .BinaryOperator(content) : leftBound ? .PostfixOperator(content) : .PrefixOperator(content)
+        let type: TokenType = leftBound == rightBound ? .BinaryOperator(content) : leftBound ? .PostfixOperator(content) : .PrefixOperator(content)
 
         return makeToken(type: type, range: start..<self.index)
     }
diff --git a/Sources/parser.swift b/Sources/parser.swift
@@ -18,7 +18,7 @@ class Parser {
     func parseType() -> Type {
         var type: Type = .Unknown
         let token = self.lexer.lexNextToken()
-        type_switch: switch token.type {
+        typeSwitch: switch token.type {
             case .Punctuator(.LeftSquare):
                 let key = self.parseType()
                 var value: Type? = nil
@@ -31,18 +31,18 @@ class Parser {
                     self.diagnose("Expected ], found \(after.content)")
                     break
                 }
-                if let actual_value = value {
-                    type = .DictionaryType(key, actual_value)
+                if let actualValue = value {
+                    type = .DictionaryType(key, actualValue)
                 } else {
                     type = .ArrayType(key)
                 }
             case .Punctuator(.LeftParenthesis):
                 var after: Token
-                var tuple_args = [Type]()
+                var tupleArgs = [Type]()
                 repeat {
                     let inner = self.parseType()
                     after = self.lexer.lexNextToken()
-                    tuple_args.append(inner)
+                    tupleArgs.append(inner)
                 } while after.type == .Punctuator(.Comma)
                 guard after.type == .Punctuator(.RightParenthesis) else {
                     self.diagnose("Expected ), found \(after.content)")
@@ -51,24 +51,24 @@ class Parser {
                 after = self.lexer.peekNextToken()
                 if after.type == .Punctuator(.Arrow) {
                     _ = self.lexer.lexNextToken()
-                    let return_type = self.parseType()
-                    type = .FunctionType(tuple_args, return_type)
+                    let returnType = self.parseType()
+                    type = .FunctionType(tupleArgs, returnType)
                 } else {
-                    type = .TupleType(tuple_args)
+                    type = .TupleType(tupleArgs)
                 }
             case .Identifier(_):
-                var parts = [((Identifier, [Type]))]()
-                var ident_token = token
-                identifier_loop: repeat {
-                    let identifier = Identifier(ident_token.content)
+                var parts = [(Identifier, [Type])]()
+                var identToken = token
+                identifierLoop: repeat {
+                    let identifier = Identifier(identToken.content)
                     switch self.lexer.peekNextToken().type {
                         case .Punctuator(.Period):
                             parts.append((identifier, []))
                             let dot = self.lexer.lexNextToken()
-                            ident_token = self.lexer.lexNextToken()
-                            if ident_token.type == .Identifier(false) && (ident_token.content == "Type" || ident_token.content == "Protocol") {
+                            identToken = self.lexer.lexNextToken()
+                            if identToken.type == .Identifier(false) && (identToken.content == "Type" || identToken.content == "Protocol") {
                                 self.lexer.resetToBeginning(of: dot)
-                                break identifier_loop
+                                break identifierLoop
                             }
                         case .BinaryOperator("<"):
                             var generics = [Type]()
@@ -79,22 +79,22 @@ class Parser {
                             let after = self.lexer.lexNextToken()
                             if case let .PostfixOperator(op) = after.type, op.hasPrefix(">") {
                                 if op != ">" {
-                                    let next_index = self.lexer.getIndex(after: after.range.range.lowerBound)
-                                    self.lexer.resetIndex(to: next_index)
+                                    let nextIndex = self.lexer.getIndex(after: after.range.range.lowerBound)
+                                    self.lexer.resetIndex(to: nextIndex)
                                 }
                             } else {
                                 self.diagnose("Expected >, found \(after.content)")
-                                break type_switch
+                                break typeSwitch
                             }
                             parts.append((identifier, generics))
                             guard self.lexer.peekNextToken().type == .Punctuator(.Period) else {
-                                break identifier_loop
+                                break identifierLoop
                             }
                             _ = self.lexer.lexNextToken()
-                            ident_token = self.lexer.lexNextToken()
+                            identToken = self.lexer.lexNextToken()
                         default:
                             parts.append((identifier, []))
-                            break identifier_loop
+                            break identifierLoop
                     }
                 } while true
                 type = .TypeIdentifier(parts)
@@ -104,7 +104,7 @@ class Parser {
                 print("Error: " + String(describing: token))
         }
 
-        postfix_loop: while true {
+        postfixLoop: while true {
             let nextToken = self.lexer.peekNextToken()
             switch nextToken.type {
                 case .Punctuator(.PostfixExclaimationMark):
@@ -124,11 +124,11 @@ class Parser {
                                 type = .MetaProtocol(type)
                             default:
                                 self.lexer.resetToBeginning(of: nextToken)
-                                break postfix_loop
+                                break postfixLoop
                         }
                     }
                 default:
-                    break postfix_loop
+                    break postfixLoop
             }
         }
 
@@ -144,18 +144,18 @@ class Parser {
         guard kwtoken.type == .DeclarationKeyword(.PrecedenceGroup) else {
             preconditionFailure("Should only parsePrecedenceGroup at the beginning of a precedencegroup declaration")
         }
-        let ident_token = lexer.lexNextToken()
-        guard case .Identifier(_) = ident_token.type else {
+        let identToken = lexer.lexNextToken()
+        guard case .Identifier(_) = identToken.type else {
             let error = self.diagnose("Expected identifier after 'precedencegroup'")
-            if ident_token.type == .Punctuator(.LeftBrace) || lexer.peekNextToken().type == .Punctuator(.LeftBrace) {
+            if identToken.type == .Punctuator(.LeftBrace) || lexer.peekNextToken().type == .Punctuator(.LeftBrace) {
                 skipWhile { $0.type != .Punctuator(.RightBrace) }
             }
             consumeIf(type: .Punctuator(.RightBrace))
             throw error
         }
 
         var valid = true
-        let name = ident_token.content
+        let name = identToken.content
         var higherThan: [Identifier]? = nil
         var lowerThan: [Identifier]? = nil
         var associativity: Associativity? = nil
@@ -167,13 +167,13 @@ class Parser {
             consumeIf(type: .Punctuator(.RightBrace))
         }
 
-        let open_brace = lexer.lexNextToken()
-        guard open_brace.type == .Punctuator(.LeftBrace) else {
+        let openBrace = lexer.lexNextToken()
+        guard openBrace.type == .Punctuator(.LeftBrace) else {
             throw self.diagnose("Expected '{' after name of precedence group")
         }
-        var attribute_name_token: Token = lexer.lexNextToken()
-        while attribute_name_token.type == .Identifier(false) {
-            let name = attribute_name_token.content
+        var attributeNameToken: Token = lexer.lexNextToken()
+        while attributeNameToken.type == .Identifier(false) {
+            let name = attributeNameToken.content
             let colon = lexer.lexNextToken()
             if colon.type != .Punctuator(.Colon) {
                 self.diagnose("Expected colon after attribute name in precedence group")
@@ -222,20 +222,20 @@ class Parser {
                             throw error
                         }
                         groups.append(group.content)
-                    } while (consumeIf(type: .Punctuator(.Comma)))
+                    } while consumeIf(type: .Punctuator(.Comma))
                     if name == "higherThan" {
                         higherThan = groups.map { Identifier($0) }
                     } else {
                         lowerThan = groups.map { Identifier($0) }
                     }
                 default:
-                    let error = self.diagnose("'\(name)' is not a valid precedence group attribute", at: attribute_name_token)
+                    let error = self.diagnose("'\(name)' is not a valid precedence group attribute", at: attributeNameToken)
                     abortBlock()
                     throw error
             }
-            attribute_name_token = lexer.lexNextToken()
+            attributeNameToken = lexer.lexNextToken()
         }
-        guard attribute_name_token.type == .Punctuator(.RightBrace) else {
+        guard attributeNameToken.type == .Punctuator(.RightBrace) else {
             throw self.diagnose("Expected operator attribute identifier in precedence group body")
         }
         return PrecedenceGroupDeclaration(
@@ -298,4 +298,5 @@ class Parser {
         diagnoses.append(diag)
         return diag
     }
+
 }
diff --git a/Sources/source.swift b/Sources/source.swift
@@ -178,6 +178,7 @@ class Source {
 }
 
 struct SourceLocation: CustomStringConvertible {
+
     let source: Source
     let index: Source.Index
 
@@ -195,12 +196,15 @@ struct SourceLocation: CustomStringConvertible {
 }
 
 extension SourceLocation: Equatable {
+
     static func == (lhs: SourceLocation, rhs: SourceLocation) -> Bool {
         return lhs.source === rhs.source && lhs.index == rhs.index
     }
+
 }
 
 struct SourceRange: CustomStringConvertible {
+
     let source: Source
     let range: Range<Source.Index>
 
@@ -224,19 +228,25 @@ struct SourceRange: CustomStringConvertible {
         }
         return "\(source.identifier):\(startLine):\(start.column)-\(endLine):\(end.column)"
     }
+
 }
 
 extension SourceRange: Equatable {
+
     static func == (lhs: SourceRange, rhs: SourceRange) -> Bool {
         return lhs.source === rhs.source && lhs.range == rhs.range
     }
+
 }
 
 extension SourceRange {
+
     init(source: Source, index: Source.Index) {
         self.init(source: source, range: index..<index)
     }
+
     init(location: SourceLocation) {
         self.init(source: location.source, index: location.index)
     }
+
 }
diff --git a/Sources/token.swift b/Sources/token.swift
@@ -353,7 +353,7 @@ public enum TokenType {
     }
 
     var isWhitespace: Bool {
-        switch (self) {
+        switch self {
             case .Whitespace, .Comment(_): return true
             default: return false
         }
diff --git a/Sources/types.swift b/Sources/types.swift
@@ -1,4 +1,5 @@
 indirect enum Type: CustomStringConvertible {
+
     typealias IdentifierWithGeneric = (Identifier, [Type])
 
     case ArrayType(Type)
@@ -21,8 +22,8 @@ indirect enum Type: CustomStringConvertible {
                 return "[\(inner)]"
             case let .DictionaryType(key, value):
                 return "[\(key): \(value)]"
-            case let .FunctionType(parameters, return_type):
-                return "(\((parameters.map { $0.description }).joined(separator: ", "))) -> \(return_type)"
+            case let .FunctionType(parameters, returnType):
+                return "(\((parameters.map { $0.description }).joined(separator: ", "))) -> \(returnType)"
             case let .TupleType(types):
                 return "(\((types.map { $0.description }).joined(separator: ", ")))"
             case let .TypeIdentifier(parts):
@@ -56,9 +57,11 @@ indirect enum Type: CustomStringConvertible {
     static func Identifier(_ name: String) -> Type {
         return .TypeIdentifier([(OriginalIdentifier(name), [])])
     }
+
 }
 
 class Identifier: CustomStringConvertible {
+
     var name: String
 
     init(_ name: String) {
@@ -68,6 +71,7 @@ class Identifier: CustomStringConvertible {
     var description: String {
         return self.name
     }
+
 }
 
 typealias OriginalIdentifier = Identifier
diff --git a/Tests/SwiftParserTests/ParsePrecedenceGroupTests.swift b/Tests/SwiftParserTests/ParsePrecedenceGroupTests.swift
@@ -148,10 +148,10 @@ class ParsePrecedenceGroupTests: ParserTestCase {
         line: UInt = #line
     ) -> (PrecedenceGroupDeclaration) -> () {
         return { group in
-            let actual_higher = Set(group.higherThan.map { $0.name })
-            XCTAssertEqual(actual_higher, higherThan, "Wrong 'higherThan' for precedence group.", file: file, line: line)
-            let actual_lower = Set(group.lowerThan.map { $0.name })
-            XCTAssertEqual(actual_lower, lowerThan, "Wrong 'lowerThan' for precedence group.", file: file, line: line)
+            let actualHigher = Set(group.higherThan.map { $0.name })
+            XCTAssertEqual(actualHigher, higherThan, "Wrong 'higherThan' for precedence group.", file: file, line: line)
+            let actualLower = Set(group.lowerThan.map { $0.name })
+            XCTAssertEqual(actualLower, lowerThan, "Wrong 'lowerThan' for precedence group.", file: file, line: line)
             XCTAssertEqual(group.associativity, associativity, "Wrong 'associativity' for precedence group.", file: file, line: line)
             XCTAssertEqual(group.assignment, assignment, "Wrong 'assignment' for precedence group.", file: file, line: line)
         }
diff --git a/Tests/SwiftParserTests/ParserTestCase.swift b/Tests/SwiftParserTests/ParserTestCase.swift

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`protocol ASTNode: CustomStringConvertible {`
	`2`	`+`
`2`	`3`	`}`
`3`	`4`
`4`	`5`	`protocol Statement: ASTNode {`
`@@ -24,6 +25,7 @@ protocol Declaration: ASTNode {`
`24`	`25`	`}`
`25`	`26`
`26`	`27`	`class BaseDeclaration: Declaration {`
	`28`	`+`
`27`	`29`	`let name: String`
`28`	`30`
`29`	`31`	`init(_ name: String) {`
`@@ -35,6 +37,7 @@ class BaseDeclaration: Declaration {`
`35`	`37`	`preconditionFailure("This method must be overridden")`
`36`	`38`	`}`
`37`	`39`	`}`
	`40`	`+`
`38`	`41`	`}`
`39`	`42`
`40`	`43`	`protocol OperatorDeclaration: Declaration {`
`@@ -58,6 +61,7 @@ class PostfixOperatorDeclaration: BaseDeclaration, OperatorDeclaration {`
`58`	`61`	`}`
`59`	`62`
`60`	`63`	`class InfixOperatorDeclaration: BaseDeclaration, OperatorDeclaration {`
	`64`	`+`
`61`	`65`	`let precedenceGroupName: String?`
`62`	`66`
`63`	`67`	`init(_ name: String, precedenceGroup: String? = nil) {`
`@@ -71,13 +75,15 @@ class InfixOperatorDeclaration: BaseDeclaration, OperatorDeclaration {`
`71`	`75`	`}`
`72`	`76`	`return "infix operator \(name)"`
`73`	`77`	`}`
	`78`	`+`
`74`	`79`	`}`
`75`	`80`
`76`	`81`	`enum Associativity {`
`77`	`82`	`case Left, Right, None`
`78`	`83`	`}`
`79`	`84`
`80`	`85`	`class PrecedenceGroupDeclaration: BaseDeclaration {`
	`86`	`+`
`81`	`87`	let `higherThan`: [Identifier]
`82`	`88`	let `lowerThan`: [Identifier]
`83`	`89`	let `associativity`: Associativity
Original file line number	Diff line number	Diff line change
`@@ -104,10 +104,10 @@ class Diagnose: Error, CustomStringConvertible {`
`104`	`104`	`description += "^" * max(count, 1)`
`105`	`105`	`if !fixIts.isEmpty {`
`106`	`106`	`description += "\n\nFix:\n"`
`107`		`- description += fixIts.map{String(describing: $0)}.joined(separator: "\n")`
	`107`	`+ description += fixIts.map { String(describing: $0) }.joined(separator: "\n")`
`108`	`108`	`}`
`109`	`109`	`if !related.isEmpty {`
`110`		`- description += "\n\n" + related.map{String(describing: $0)}.joined(separator: "\n")`
	`110`	`+ description += "\n\n" + related.map { String(describing: $0) }.joined(separator: "\n")`
`111`	`111`	`}`
`112`	`112`	`return description`
`113`	`113`	`}`
Original file line number	Diff line number	Diff line change
`@@ -199,11 +199,11 @@ extension String {`
`199`	`199`	`return self.characters.count`
`200`	`200`	`}`
`201`	`201`
`202`		`- subscript (i: Int) -> Character {`
	`202`	`+ subscript(i: Int) -> Character {`
`203`	`203`	`return self.characters[index(startIndex, offsetBy: i)]`
`204`	`204`	`}`
`205`	`205`
`206`		`- subscript (range: Range<Int>) -> String {`
	`206`	`+ subscript(range: Range<Int>) -> String {`
`207`	`207`	`let startOffset = clamp(range.lowerBound, lower: 0, upper: length)`
`208`	`208`	`let endOffset = clamp(range.upperBound, lower: 0, upper: length)`
`209`	`209`	`let start = index(startIndex, offsetBy: startOffset)`
Original file line number	Diff line number	Diff line change
`@@ -540,7 +540,7 @@ class Lexer: Sequence {`
`540`	`540`	`break`
`541`	`541`	`}`
`542`	`542`
`543`		`- let type: TokenTypev = leftBound == rightBound ? .BinaryOperator(content) : leftBound ? .PostfixOperator(content) : .PrefixOperator(content)`
	`543`	`+ let type: TokenType = leftBound == rightBound ? .BinaryOperator(content) : leftBound ? .PostfixOperator(content) : .PrefixOperator(content)`
`544`	`544`
`545`	`545`	`return makeToken(type: type, range: start..<self.index)`
`546`	`546`	`}`
Original file line number	Diff line number	Diff line change
`@@ -178,6 +178,7 @@ class Source {`
`178`	`178`	`}`
`179`	`179`
`180`	`180`	`struct SourceLocation: CustomStringConvertible {`
	`181`	`+`
`181`	`182`	`let source: Source`
`182`	`183`	`let index: Source.Index`
`183`	`184`
`@@ -195,12 +196,15 @@ struct SourceLocation: CustomStringConvertible {`
`195`	`196`	`}`
`196`	`197`
`197`	`198`	`extension SourceLocation: Equatable {`
	`199`	`+`
`198`	`200`	`static func == (lhs: SourceLocation, rhs: SourceLocation) -> Bool {`
`199`	`201`	`return lhs.source === rhs.source && lhs.index == rhs.index`
`200`	`202`	`}`
	`203`	`+`
`201`	`204`	`}`
`202`	`205`
`203`	`206`	`struct SourceRange: CustomStringConvertible {`
	`207`	`+`
`204`	`208`	`let source: Source`
`205`	`209`	`let range: Range<Source.Index>`
`206`	`210`
`@@ -224,19 +228,25 @@ struct SourceRange: CustomStringConvertible {`
`224`	`228`	`}`
`225`	`229`	`return "\(source.identifier):\(startLine):\(start.column)-\(endLine):\(end.column)"`
`226`	`230`	`}`
	`231`	`+`
`227`	`232`	`}`
`228`	`233`
`229`	`234`	`extension SourceRange: Equatable {`
	`235`	`+`
`230`	`236`	`static func == (lhs: SourceRange, rhs: SourceRange) -> Bool {`
`231`	`237`	`return lhs.source === rhs.source && lhs.range == rhs.range`
`232`	`238`	`}`
	`239`	`+`
`233`	`240`	`}`
`234`	`241`
`235`	`242`	`extension SourceRange {`
	`243`	`+`
`236`	`244`	`init(source: Source, index: Source.Index) {`
`237`	`245`	`self.init(source: source, range: index..<index)`
`238`	`246`	`}`
	`247`	`+`
`239`	`248`	`init(location: SourceLocation) {`
`240`	`249`	`self.init(source: location.source, index: location.index)`
`241`	`250`	`}`
	`251`	`+`
`242`	`252`	`}`
Original file line number	Diff line number	Diff line change
`@@ -353,7 +353,7 @@ public enum TokenType {`
`353`	`353`	`}`
`354`	`354`
`355`	`355`	`var isWhitespace: Bool {`
`356`		`- switch (self) {`
	`356`	`+ switch self {`
`357`	`357`	`case .Whitespace, .Comment(_): return true`
`358`	`358`	`default: return false`
`359`	`359`	`}`