Support optional instance names

Author: natefaubion

src/PureScript/CST/Parser.purs

@@ -298,17 +298,19 @@ parseInstanceChainSeparator =
 parseInstance :: Parser (Recovered Instance)
 parseInstance = do
   keyword <- tokKeyword "instance"
-  name <- parseIdent
-  separator <- tokDoubleColon
+  name <- optional parseInstanceName
   constraints <- optional $ try $ Tuple <$> parseClassConstraints parseType3 <*> tokRightFatArrow
   className <- parseQualifiedProper
   types <- many parseTypeAtom
   body <- optional $ Tuple <$> tokKeyword "where" <*> layoutNonEmpty parseInstanceBinding
   pure $ Instance
-    { head: { keyword, name, separator, constraints, className, types }
+    { head: { keyword, name, constraints, className, types }
     , body
     }
 
+parseInstanceName :: Parser (Tuple (Name Ident) SourceToken)
+parseInstanceName = Tuple <$> parseIdent <*> tokDoubleColon
+
 parseInstanceBinding :: Parser (Recovered InstanceBinding)
 parseInstanceBinding = do
   ident <- parseIdent
@@ -332,12 +334,11 @@ parseDeclDerive = do
   derive_ <- tokKeyword "derive"
   newtype_ <- optional $ tokKeyword "newtype"
   keyword <- tokKeyword "instance"
-  name <- parseIdent
-  separator <- tokDoubleColon
+  name <- optional parseInstanceName
   constraints <- optional $ try $ Tuple <$> parseClassConstraints parseType3 <*> tokRightFatArrow
   className <- parseQualifiedProper
   types <- many parseTypeAtom
-  pure $ DeclDerive derive_ newtype_ { keyword, name, separator, constraints, className, types }
+  pure $ DeclDerive derive_ newtype_ { keyword, name, constraints, className, types }
 
 parseDeclValue :: Parser (Recovered Declaration)
 parseDeclValue = do

src/PureScript/CST/Range.purs

@@ -513,8 +513,7 @@ instance tokensOfDecl :: TokensOf e => TokensOf (Declaration e) where
       cons keyword $ defer \_ ->
         foldMap singleton tok
           <> singleton inst.keyword
-          <> tokensOf inst.name
-          <> singleton inst.separator
+          <> foldMap (\(Tuple cs t) -> tokensOf cs <> singleton t) inst.name
           <> foldMap (\(Tuple cs t) -> tokensOf cs <> singleton t) inst.constraints
           <> tokensOf inst.className
           <> tokensOf inst.types
@@ -577,8 +576,7 @@ instance rangeOfInstance :: RangeOf e => RangeOf (Instance e) where
 instance tokensOfInstance :: TokensOf e => TokensOf (Instance e) where
   tokensOf (Instance { head, body }) =
     cons head.keyword $ defer \_ ->
-      tokensOf head.name
-        <> singleton head.separator
+      foldMap (\(Tuple cs t) -> tokensOf cs <> singleton t) head.name
         <> foldMap (\(Tuple cs t) -> tokensOf cs <> singleton t) head.constraints
         <> tokensOf head.className
         <> tokensOf head.types

src/PureScript/CST/Types.purs

@@ -294,8 +294,7 @@ data ClassFundep
 
 type InstanceHead e =
   { keyword :: SourceToken
-  , name :: Name Ident
-  , separator :: SourceToken
+  , name :: Maybe (Tuple (Name Ident) SourceToken)
   , constraints :: Maybe (Tuple (OneOrDelimited (Type e)) SourceToken)
   , className :: QualifiedName Proper
   , types :: Array (Type e)