labeled-statement :
+   | statement-label   do-statement

var i = 0
label1: do {
    print("i = \(i++)")
    if i < 3 {
        continue label1
    }
}

  initializer-declaration:
-     initializer-head   generic-parameter-clause?   parameter-clause   WORD-THROWS?    initializer-body
+     initializer-head   generic-parameter-clause?   parameter-clause   WORD-THROWS?    initializer-body?
-   | initializer-head   generic-parameter-clause?   parameter-clause   WORD-RETHROWS   initializer-body
+   | initializer-head   generic-parameter-clause?   parameter-clause   WORD-RETHROWS   initializer-body?

// In framework Module "Darwin"
public struct DarwinBoolean : BooleanType, BooleanLiteralConvertible {
    public init(_ value: Bool)
    /// Create an instance initialized to `value`.
    public init(booleanLiteral value: Bool)
}

  declaration: 
+   | compiler-control-statement (SEMICOLON)*

/* 
 * class-declaration : ... class-body
 * class-body : { declarations? }
 * declarations : declaration+
 */
class CCC {
    #if DEBUG
        func foo() {print("foo-debug")}
    #else
        func foo() {print("foo-normal")}
    #endif
}
CCC().foo()

  setter-keyword-clause:
-     attributes?   set
+     attributes?   nonmutating?   set

// In framework module "Swift"
public struct AutoreleasingUnsafeMutablePointer<Memory> : Equatable, NilLiteralConvertible, _PointerType {
    ...
    public var memory: Memory { get nonmutating set }
    ...
}

  typealias-assignment 
-   :  =    type
+   :  =    attributes?    type

// In framework module "CFNetwork.CFHost"
public typealias CFHostClientCallBack = @convention(c) (CFHost, CFHostInfoType, UnsafePointer<CFStreamError>, UnsafeMutablePointer<Void>) -> Void

  parameter:
-     let?   external-parameter-name?   local-parameter-name   type-annotation  default-argument-clause?
+     let?   external-parameter-name?   local-parameter-name   type-annotation?  default-argument-clause?
-   | var    external-parameter-name?   local-parameter-name   type-annotation   default-argument-clause?
+   | var    external-parameter-name?   local-parameter-name   type-annotation?   default-argument-clause?

var names = ["a", "b", "c"]
var reversed = names.sort( { (s1, s2) -> Bool in return s1 > s2 } )
reversed = names.sort( { (s1, var s2) -> Bool in return s1 > s2 } )

  parameter:
-     let?   external-parameter-name?   local-parameter-name   type-annotation?   default-argument-clause?
+     attributes?   let?   external-parameter-name?   local-parameter-name   type-annotation?   default-argument-clause?
-   | var    external-parameter-name?   local-parameter-name   type-annotation?   default-argument-clause?
+   | attributes?   var    external-parameter-name?   local-parameter-name   type-annotation?   default-argument-clause?

public class CC {
    func kkk (lhs: Bool, @autoclosure rhs: () throws -> Bool) rethrows -> Bool {return true}
}

  default_argument_clause:   
+   |  =  default

// In framework module "Swift"
extension ContiguousArray : _ArrayType {
    public mutating func removeAll(keepCapacity keepCapacity: Bool = default)
}
/*
 * According to subsection "Keywords and Punctuation", "default" is a keyword and cannot be used as identifiers.
 * So, "default" cannot be matched by the "expression" rule
 */

  class-declaration: 
-     attributes­?   ­access-level-modifier­?   ­class   ­class-name   ­generic-parameter-clause­?   ­type-inheritance-clause­?   ­class-body­
+     attributes­?   ­declaration-modifiers?   ­class   ­class-name   ­generic-parameter-clause­?   ­type-inheritance-clause­?   ­class-body­

/*
 * "final public" cannot be matched by "access-level-modifier"
 */
final public class CC {
}

  extension-declaration: 
-     access-level-modifier­?   ­extension   ­type-identifier   ­type-inheritance-clause?   ­­extension-body­
+     attributes?   access-level-modifier­?   ­extension   ­type-identifier   ­type-inheritance-clause?   ­­extension-body­ 

@available(OSX 10.10, *)
extension TT  {
    static var _NSErrorDomain: String {
        get {return "_NSErrorDomain"}
    }
    typealias RawValue = Int
}

  extension-declaration:
-     attributes?   access-level-modifier­?   ­extension   ­type-identifier   ­type-inheritance-clause?   ­­extension-body­
+     attributes?   access-level-modifier­?   ­extension   ­type-identifier   ­type-inheritance-clause?   requirement_clause?   ­­extension-body­

// In framework module "Swift.swift"
extension BidirectionalIndexType where Self : ReverseIndexType {
   ...
}

  subscript-declaration:  
-      subscript-head­   subscript-result   ­code-block­
+      subscript-head­   subscript-result   ­code-block­? 

// In framework module "Swift"
public struct ContiguousArray<Element> : CollectionType, MutableCollectionType, _DestructorSafeContainer {
    ...
    public subscript (index: Int) -> Element
    public subscript (subRange: Range<Int>) -> ArraySlice<Element>
}

  infix-operator-attributes: 
-     precedence-clause­?   ­associativity-clause?
+     precedence-clause­?   ­associativity-clause?   assignment?

infix operator %**= {
  precedence 90
  associativity right
  assignment
}

  infix-operator-attributes: 
-     precedence-clause­?   ­associativity-clause?
+     precedence-clause­?   ­associativity-clause?   assignment?
+     precedence-clause­?   ­assignment?   associativity-clause?
+     assignment?   precedence-clause­?   ­associativity-clause?
+     assignment?   ­associativity-clause?   precedence-clause­?
+     associativity-clause?   assignment?   ­precedence-clause­?
+     associativity-clause?   ­precedence-clause­?   assignment?

infix operator %**= {
  associativity right
  precedence 90
  assignment
}

  enum-case-pattern: 
-     type-identifier­?   ­.   ­enum-case-name   ­tuple-pattern­?
+     type-identifier­?   ­.?   ­enum-case-name   ­tuple-pattern­?

public enum car{
    case SUV
    case UNKNOWN   
    public func printCar() {
        switch self {
            case SUV:
                print("SUV")
            case .SUV:        // Warning: Case will never be executed
                print("SUV-2")
            default:
                print("default")
        }
    }
}

  closure-expression: 
-     {  closure-signature?   statements   }
+     {  closure-signature?   statements?   }

func foo(f:Int->()) {}
foo({(x:Int) in })

  expression-element:
+      operator

// In Operator Functions in Language Guide
// ">" cannot be matched by "expression"
var names = ["a", "b", "c"]
var reversed = names.sort(>)