               rightTypeIdentifier: secondType,
               arena: self.arena))
           }
-        } else if (self.currentToken.isAnyOperator && self.currentToken.tokenText == "==") || self.at(.equal) {
+        case (.spacedBinaryOperator, _)?,
+          (.unspacedBinaryOperator, _)?,
+          (.postfixOperator, _)?,
+          (.prefixOperator, _)?:
           let equal = self.consumeAnyToken()
           let secondType = self.parseType()
           requirement = RawSyntax(RawSameTypeRequirementSyntax(

            equalityToken: equal,
            rightTypeIdentifier: secondType,
            arena: self.arena))
        } else {
          requirement = RawSyntax(RawSameTypeRequirementSyntax(
            leftTypeIdentifier: firstType,
            equalityToken: RawTokenSyntax(missing: .equal, arena: self.arena),

          semicolon: semicolon,
          arena: parser.arena)
      }
                           syntax: { parser, elements in
        return RawSyntax(RawMemberDeclListSyntax(elements: elements, arena: parser.arena))
      })
    case (.poundWarningKeyword, _)?, (.poundErrorKeyword, _)?:
      return self.parsePoundDiagnosticDeclaration()
    case nil:
      break
    }

    enum DeclStartTokenKind: RawTokenKindSubset {
      case importKeyword
      case classKeyword
      case enumKeyword
      case caseKeyword
      case structKeyword
      case protocolKeyword
      case associatedtypeKeyword
      case typealiasKeyword
      case extensionKeyword
      case funcKeyword
      case subscriptKeyword
      case letKeyword
      case varKeyword
      case initKeyword
      case deinitKeyword
      case operatorKeyword
      case precedencegroupKeyword
      case actor

      var contextualKeyword: SyntaxText? {
        switch self {
        case .actor: return "actor"
        default: return nil
        }
      }

      var rawTokenKind: RawTokenKind {
        switch self {
        case .importKeyword: return .importKeyword
        case .classKeyword: return .classKeyword
        case .enumKeyword: return .enumKeyword
        case .caseKeyword: return .caseKeyword
        case .structKeyword: return .structKeyword
        case .protocolKeyword: return .protocolKeyword
        case .associatedtypeKeyword: return .associatedtypeKeyword
        case .typealiasKeyword: return .typealiasKeyword
        case .extensionKeyword: return .extensionKeyword
        case .funcKeyword: return .funcKeyword
        case .subscriptKeyword: return .subscriptKeyword
        case .letKeyword: return .letKeyword
        case .varKeyword: return .varKeyword
        case .initKeyword: return .initKeyword
        case .deinitKeyword: return .deinitKeyword
        case .operatorKeyword: return .operatorKeyword
        case .precedencegroupKeyword: return .precedencegroupKeyword
        case .actor: return .identifier
        }
      }
    }

    let attrs = DeclAttributes(
      attributes: self.parseAttributeList(),
      modifiers: self.parseModifierList())
    switch self.at(anyIn: DeclStartTokenKind.self) {
    case (.importKeyword, _)?:
      return RawDeclSyntax(self.parseImportDeclaration(attrs))
    case (.classKeyword, _)?:
      return RawDeclSyntax(self.parseClassDeclaration(attrs))
    case (.enumKeyword, _)?:
      return RawDeclSyntax(self.parseEnumDeclaration(attrs))
    case (.caseKeyword, _)?:
      return RawDeclSyntax(self.parseDeclEnumCase(attrs))
    case (.structKeyword, _)?:
      return RawDeclSyntax(self.parseStructDeclaration(attrs))
    case (.protocolKeyword, _)?:
      return RawDeclSyntax(self.parseProtocolDeclaration(attrs))
    case (.associatedtypeKeyword, _)?:
      return RawDeclSyntax(self.parseAssociatedTypeDeclaration(attrs))
    case (.typealiasKeyword, _)?:
      return RawDeclSyntax(self.parseTypealiasDeclaration(attrs))
    case (.extensionKeyword, _)?:
      return RawDeclSyntax(self.parseExtensionDeclaration(attrs))
    case (.funcKeyword, _)?:
      return RawDeclSyntax(self.parseFuncDeclaration(attrs))
    case (.subscriptKeyword, _)?:
      return RawDeclSyntax(self.parseSubscriptDeclaration(attrs))
    case (.letKeyword, _)?,
      (.varKeyword, _)?:
      return RawDeclSyntax(self.parseLetOrVarDeclaration(attrs))
    case (.initKeyword, _)?:
      return RawDeclSyntax(self.parseInitializerDeclaration(attrs))
    case (.deinitKeyword, _)?:
      return RawDeclSyntax(self.parseDeinitializerDeclaration(attrs))
    case (.operatorKeyword, _)?:
      return RawDeclSyntax(self.parseOperatorDeclaration(attrs))
    case (.precedencegroupKeyword, _)?:
      return RawDeclSyntax(self.parsePrecedenceGroupDeclaration(attrs))
    case (.actor, _)?:
      return RawDeclSyntax(self.parseActorDeclaration(attrs))
    case nil:
      return RawDeclSyntax(RawMissingDeclSyntax(
        attributes: attrs.attributes,
        modifiers: attrs.modifiers,
