             if let m = almod {
                 mods.insert(m, atIndex: 0)
             }
-            return try protocolPropertyDeclaration(attrs, mods)
+            return try moduleVariableDeclaration(attrs, mods)
         case .Typealias:
             if mods.count > 0 {
                 try ts.error(.ModifierBeforeTypealias)
             }
-            return try protocolAssociatedTypeDeclaration(attrs, almod)
+            return try AssociatedTypeDeclaration(attrs, almod)
         case .Func:
             if let m = almod {
                 mods.insert(m, atIndex: 0)
             }
-            return try functionDeclaration(attrs, mods, forProtocol: true)
+            return try functionDeclaration(attrs, mods, forModule: true)
         case .Init:
             if let m = almod {
                 mods.insert(m, atIndex: 0)
             }
-            return try initializerDeclaration(attrs, mods, forProtocol: true)
+            return try initializerDeclaration(attrs, mods, forModule: true)
         case .Subscript:
             if let m = almod {
                 mods.insert(m, atIndex: 0)
             }
-            return try protocolSubscriptDeclaration(attrs, mods)
+            return try moduleSubscriptDeclaration(attrs, mods)
         default:
             throw ts.fatal(.ExpectedDeclaration)
         }
     }
 
-    private func protocolPropertyDeclaration(
+    private func moduleVariableDeclaration(
         attrs: [Attribute], _ mods: [Modifier]
     ) throws -> VariableBlockDeclaration {
         let trackable = ts.look()

        x.params = try parameterClauses()
        x.throwType = throwType()
        x.returns = try functionResult()
        if forProtocol {
            if case .LeftBrace = ts.look().kind {
                try ts.error(.ProcedureInDeclarationOfProtocol)
            }

    }

    private func initializerDeclaration(
        attrs: [Attribute], _ mods: [Modifier], forModule: Bool = false
    ) throws -> InitializerDeclaration {
        let x = InitializerDeclaration(attrs, mods)
        switch ts.match([.PostfixQuestion, .PostfixExclamation]) {
