Delete old serialization code

Author: Hendrik van Antwerpen

stack-graphs/src/json.rs

@@ -5,9 +5,6 @@
 // Please see the LICENSE-APACHE or LICENSE-MIT files in this distribution for license details.
 // ------------------------------------------------------------------------------------------------
 
-use lsp_positions::Offset;
-use lsp_positions::Position;
-use lsp_positions::Span;
 use serde::ser::Serialize;
 use serde::ser::SerializeSeq;
 use serde::ser::SerializeStruct;
@@ -17,13 +14,8 @@ use std::ops::Index;
 use thiserror::Error;
 
 use crate::arena::Handle;
-use crate::graph::DebugEntry;
-use crate::graph::DebugInfo;
-use crate::graph::Edge;
 use crate::graph::File;
-use crate::graph::Node;
 use crate::graph::NodeID;
-use crate::graph::SourceInfo;
 use crate::graph::StackGraph;
 use crate::partial::PartialPath;
 use crate::partial::PartialPathEdge;
@@ -34,8 +26,9 @@ use crate::partial::PartialScopedSymbol;
 use crate::partial::PartialSymbolStack;
 use crate::partial::ScopeStackVariable;
 use crate::partial::SymbolStackVariable;
+pub use crate::serde::Filter;
 use crate::serde::ImplicationFilter;
-pub use crate::serde::{Filter, NoFilter};
+pub use crate::serde::NoFilter;
 use crate::stitching::Database;
 
 #[derive(Debug, Error)]
@@ -63,24 +56,6 @@ impl<'a, T> InStackGraph<'a, T> {
 //-----------------------------------------------------------------------------
 // Files
 
-struct Files;
-
-impl<'a> Serialize for InStackGraph<'a, &Files> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let graph = self.0;
-        let filter = self.2;
-
-        let mut ser = serializer.serialize_seq(None)?;
-        for file in graph.iter_files().filter(|f| filter.include_file(graph, f)) {
-            ser.serialize_element(&self.with_idx(file))?;
-        }
-        ser.end()
-    }
-}
-
 impl Serialize for InStackGraph<'_, (Handle<File>, &File)> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -94,111 +69,6 @@ impl Serialize for InStackGraph<'_, (Handle<File>, &File)> {
 //-----------------------------------------------------------------------------
 // Nodes
 
-struct Nodes;
-
-impl Serialize for InStackGraph<'_, &Nodes> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let graph = self.0;
-        let filter = self.2;
-
-        let mut nodes = serializer.serialize_seq(None)?;
-        for node in graph
-            .iter_nodes()
-            .filter(|n| filter.include_node(graph, &n))
-        {
-            nodes.serialize_element(&self.with_idx(node))?;
-        }
-        nodes.end()
-    }
-}
-
-impl Serialize for InStackGraph<'_, (Handle<Node>, &Node)> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let graph = self.0;
-        let handle = self.1 .0;
-        let node = self.1 .1;
-        let source_info = graph.source_info(handle);
-        let debug_info = graph.debug_info(handle);
-
-        let mut len = 2;
-        if source_info.is_some() {
-            len += 1;
-        }
-        if debug_info.is_some() {
-            len += 1;
-        }
-
-        let mut ser = match node {
-            Node::DropScopes(_node) => {
-                let mut ser = serializer.serialize_struct("node", len + 1)?;
-                ser.serialize_field("type", "drop_scopes")?;
-                ser
-            }
-            Node::JumpTo(_node) => {
-                let mut ser = serializer.serialize_struct("node", len + 1)?;
-                ser.serialize_field("type", "jump_to_scope")?;
-                ser
-            }
-            Node::PopScopedSymbol(node) => {
-                let mut ser = serializer.serialize_struct("node", len + 3)?;
-                ser.serialize_field("type", "pop_scoped_symbol")?;
-                ser.serialize_field("symbol", &graph[node.symbol])?;
-                ser.serialize_field("is_definition", &node.is_definition)?;
-                ser
-            }
-            Node::PopSymbol(node) => {
-                let mut ser = serializer.serialize_struct("node", len + 3)?;
-                ser.serialize_field("type", "pop_symbol")?;
-                ser.serialize_field("symbol", &graph[node.symbol])?;
-                ser.serialize_field("is_definition", &node.is_definition)?;
-                ser
-            }
-            Node::PushScopedSymbol(node) => {
-                let mut ser = serializer.serialize_struct("node", len + 4)?;
-                ser.serialize_field("type", "push_scoped_symbol")?;
-                ser.serialize_field("symbol", &graph[node.symbol])?;
-                ser.serialize_field("scope", &self.with(&node.scope))?;
-                ser.serialize_field("is_reference", &node.is_reference)?;
-                ser
-            }
-            Node::PushSymbol(node) => {
-                let mut ser = serializer.serialize_struct("node", len + 3)?;
-                ser.serialize_field("type", "push_symbol")?;
-                ser.serialize_field("symbol", &graph[node.symbol])?;
-                ser.serialize_field("is_reference", &node.is_reference)?;
-                ser
-            }
-            Node::Root(_node) => {
-                let mut ser = serializer.serialize_struct("node", len + 1)?;
-                ser.serialize_field("type", "root")?;
-                ser
-            }
-            Node::Scope(node) => {
-                let mut ser = serializer.serialize_struct("node", len + 2)?;
-                ser.serialize_field("type", "scope")?;
-                ser.serialize_field("is_exported", &node.is_exported)?;
-                ser
-            }
-        };
-
-        ser.serialize_field("id", &self.with(&node.id()))?;
-        if let Some(source_info) = source_info {
-            ser.serialize_field("source_info", &self.with(source_info))?;
-        }
-        if let Some(debug_info) = debug_info {
-            ser.serialize_field("debug_info", &self.with(debug_info))?;
-        }
-
-        ser.end()
-    }
-}
-
 impl Serialize for InStackGraph<'_, &Vec<NodeID>> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -231,146 +101,6 @@ impl Serialize for InStackGraph<'_, &NodeID> {
     }
 }
 
-impl Serialize for InStackGraph<'_, &SourceInfo> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let graph = self.0;
-        let source_info = self.1;
-
-        let mut len = 1;
-        if source_info.syntax_type.is_some() {
-            len += 1;
-        }
-
-        let mut ser = serializer.serialize_struct("source_info", len)?;
-        ser.serialize_field("span", &self.with(&source_info.span))?;
-        if let Some(syntax_type) = source_info.syntax_type {
-            ser.serialize_field("syntax_type", &graph[syntax_type])?;
-        }
-        ser.end()
-    }
-}
-
-impl Serialize for InStackGraph<'_, &DebugInfo> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let debug_info = self.1;
-
-        let mut ser = serializer.serialize_seq(None)?;
-        for entry in debug_info.iter() {
-            ser.serialize_element(&self.with(entry))?;
-        }
-        ser.end()
-    }
-}
-
-impl Serialize for InStackGraph<'_, &DebugEntry> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let graph = self.0;
-        let debug_entry = self.1;
-
-        let mut ser = serializer.serialize_struct("debug_entry", 2)?;
-        ser.serialize_field("key", &graph[debug_entry.key])?;
-        ser.serialize_field("value", &graph[debug_entry.value])?;
-        ser.end()
-    }
-}
-
-//-----------------------------------------------------------------------------
-// Edges
-
-struct Edges;
-
-impl Serialize for InStackGraph<'_, &Edges> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let graph = self.0;
-        let filter = self.2;
-
-        let mut ser = serializer.serialize_seq(None)?;
-        for source in graph.iter_nodes() {
-            for edge in graph
-                .outgoing_edges(source)
-                .filter(|e| filter.include_edge(graph, &e.source, &e.sink))
-            {
-                ser.serialize_element(&self.with(&edge))?;
-            }
-        }
-        ser.end()
-    }
-}
-
-impl Serialize for InStackGraph<'_, &Edge> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let graph = self.0;
-        let edge = self.1;
-
-        let mut ser = serializer.serialize_struct("edge", 3)?;
-        ser.serialize_field("source", &self.with(&graph[edge.source].id()))?;
-        ser.serialize_field("sink", &self.with(&graph[edge.sink].id()))?;
-        ser.serialize_field("precedence", &edge.precedence)?;
-        ser.end()
-    }
-}
-
-//-----------------------------------------------------------------------------
-// Span, Position, Offset
-
-impl Serialize for InStackGraph<'_, &Span> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let span = self.1;
-
-        let mut ser = serializer.serialize_struct("span", 2)?;
-        ser.serialize_field("start", &self.with(&span.start))?;
-        ser.serialize_field("end", &self.with(&span.end))?;
-        ser.end()
-    }
-}
-
-impl Serialize for InStackGraph<'_, &Position> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let position = self.1;
-
-        let mut ser = serializer.serialize_struct("position", 2)?;
-        ser.serialize_field("line", &position.line)?;
-        ser.serialize_field("column", &self.with(&position.column))?;
-        ser.end()
-    }
-}
-
-impl Serialize for InStackGraph<'_, &Offset> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let offset = self.1;
-
-        let mut ser = serializer.serialize_struct("offset", 3)?;
-        ser.serialize_field("utf8_offset", &offset.utf8_offset)?;
-        ser.serialize_field("utf16_offset", &offset.utf16_offset)?;
-        ser.serialize_field("grapheme_offset", &offset.grapheme_offset)?;
-        ser.end()
-    }
-}
-
 //-----------------------------------------------------------------------------
 // Database