Add basic support for �xcept clauses.

This seems to work nicely, but the DOT layout is awful.

Author: tmr232

src/control-flow/cfg-defs.ts

@@ -29,7 +29,7 @@ export type NodeType =
   | "SWITCH_CONDITION"
   | "SWITCH_MERGE"
   | "CASE_CONDITION";
-export type EdgeType = "regular" | "consequence" | "alternative";
+export type EdgeType = "regular" | "consequence" | "alternative" | "exception";
 
 export type ClusterType =
   | "with"

src/control-flow/cfg-python.ts

@@ -208,12 +208,29 @@ export class CFGBuilder {
     const getBlock = this.blockGetter(blockHandler);
 
     const bodySyntax = this.getSyntax(match, "try-body");
+    const exceptSyntaxMany = this.getSyntaxMany(match, "except-body");
     const finallySyntax = this.getSyntax(match, "finally-body");
     return this.withCluster("try-complex", (tryComplexCluster) => {
       const bodyBlock = this.withCluster("try", () =>
         getBlock(bodySyntax),
       ) as BasicBlock;
 
+      // We handle `except` blocks before the `finally` block to support `return` handling.
+      const exceptBlocks = exceptSyntaxMany.map((exceptSyntax) =>
+        this.withCluster("except", () => getBlock(exceptSyntax) as BasicBlock),
+      );
+      // We attach the except-blocks to the top of the `try` body.
+      // In the rendering, we will connect them to the side of the node, and use invisible lines for it.
+      if (bodyBlock.entry) {
+        const headNode = bodyBlock.entry;
+        exceptBlocks.forEach((exceptBlock) => {
+          if (exceptBlock.entry) {
+            // Yes, this is effectively a head-to-head link. But that's ok.
+            this.addEdge(headNode, exceptBlock.entry, "exception");
+          }
+        });
+      }
+
       const finallyBlock = this.withCluster("finally", () => {
         // Handle all the return statements from the try block
         if (finallySyntax) {
@@ -223,7 +240,7 @@ export class CFGBuilder {
             // so that we can link them.
             const duplicateFinallyBlock = getBlock(finallySyntax) as BasicBlock;
             // We also clone the return node, to place it _after_ the finally block
-            // We also override the cluster node, pulling it up to the `try-complex`, 
+            // We also override the cluster node, pulling it up to the `try-complex`,
             // as the return is neither in a `try`, `except`, or `finally` context.
             const returnNodeClone = this.cloneNode(returnNode, {
               cluster: tryComplexCluster,
@@ -247,8 +264,16 @@ export class CFGBuilder {
         return finallyBlock;
       });
 
-      if (bodyBlock.exit && finallyBlock?.entry)
-        this.addEdge(bodyBlock.exit, finallyBlock.entry);
+      if (finallyBlock?.entry) {
+        // Connect `try` to `finally`
+        if (bodyBlock.exit) this.addEdge(bodyBlock.exit, finallyBlock.entry);
+
+        // Connect `except` to `finally`
+        exceptBlocks.forEach((exceptBlock) => {
+          if (exceptBlock.exit)
+            this.addEdge(exceptBlock.exit, finallyBlock.entry as string);
+        });
+      }
 
       return blockHandler.update({
         entry: bodyBlock.entry,

src/control-flow/render.ts

@@ -172,37 +172,6 @@ function renderHierarchy(
   return dotContent;
 }
 
-function formatStyle(style: { [attribute: string]: number | string }): string {
-  return [...Object.entries(style)]
-    .map(([name, value]) => {
-      switch (typeof value) {
-        case "number":
-          return `${name}=${value};\n`;
-        case "string":
-          return `${name}="${value}";\n`;
-      }
-    })
-    .join("");
-}
-
-function clusterStyle(cluster: Cluster): string {
-  const isSelfNested = cluster.type === cluster.parent?.type;
-  const penwidth = isSelfNested ? 6 : 0;
-  const color = "white";
-  switch (cluster.type) {
-    case "with":
-      return formatStyle({ penwidth, color, bgcolor: "#ffddff" });
-    case "try-complex":
-      return formatStyle({ penwidth, color, bgcolor: "#ddddff" });
-    case "try":
-      return formatStyle({ penwidth, color, bgcolor: "#ddffdd" });
-    case "finally":
-      return formatStyle({ penwidth, color, bgcolor: "#ffffdd" });
-    default:
-      return "";
-  }
-}
-
 function renderSubgraphs(
   hierarchy: Hierarchy,
   verbose: boolean,
@@ -300,24 +269,69 @@ export function graphToDot(cfg: CFG, verbose: boolean = false): string {
   return dotContent;
 }
 
+type DotAttributes = { [attribute: string]: number | string | undefined };
+function formatStyle(style: DotAttributes): string {
+  return [...Object.entries(style)]
+    .map(([name, value]) => {
+      switch (typeof value) {
+        case "number":
+          return `${name}=${value};\n`;
+        case "string":
+          return `${name}="${value}";\n`;
+        case "undefined":
+          return "";
+      }
+    })
+    .join("");
+}
+
+function clusterStyle(cluster: Cluster): string {
+  const isSelfNested = cluster.type === cluster.parent?.type;
+  const penwidth = isSelfNested ? 6 : 0;
+  const color = "white";
+  switch (cluster.type) {
+    case "with":
+      return formatStyle({ penwidth, color, bgcolor: "#ffddff" });
+    case "try-complex":
+      return formatStyle({ penwidth, color, bgcolor: "#ddddff" });
+    case "try":
+      return formatStyle({ penwidth, color, bgcolor: "#ddffdd" });
+    case "finally":
+      return formatStyle({ penwidth, color, bgcolor: "#ffffdd" });
+    case "except":
+      return formatStyle({ penwidth, color, bgcolor: "#ffdddd" });
+    default:
+      return "";
+  }
+}
+
 function renderEdge(
   edge: string,
   source: string,
   target: string,
   topGraph: CFGGraph,
 ) {
   const attributes = topGraph.getEdgeAttributes(edge);
-  const penwidth = 1;
-  let color = "blue";
+  const dotAttrs: DotAttributes = {};
+  dotAttrs.penwidth = 1;
+  dotAttrs.color = "blue";
   switch (attributes.type) {
     case "consequence":
-      color = "green";
+      dotAttrs.color = "green";
       break;
     case "alternative":
-      color = "red";
+      dotAttrs.color = "red";
+      break;
+    case "regular":
+      dotAttrs.color = "blue";
+      break;
+    case "exception":
+      dotAttrs.style = "invis";
+      dotAttrs.headport = "e";
+      dotAttrs.tailport = "w";
       break;
     default:
-      color = "blue";
+      dotAttrs.color = "fuchsia";
   }
-  return `    ${source} -> ${target} [penwidth=${penwidth} color=${color}];\n`;
+  return `    ${source} -> ${target} [${formatStyle(dotAttrs)}];\n`;
 }

src/frontend/src/lib/utils.ts

@@ -136,7 +136,7 @@ export function processRecord(
   if (trim) cfg = trimFor(cfg);
   if (simplify) cfg = simplifyCFG(cfg, mergeNodeAttrs);
 
-  const dot = graphToDot(cfg, verbose);
+  const dot = graphviz.dot(graphToDot(cfg, verbose), "canon");
   const svg = graphviz.dot(dot);
 
   return { dot, ast, svg };

src/test/commentTestSamples/sample.py

@@ -156,6 +156,42 @@ def WithNestedCluster():
             return
 
 
+
+# exits: 0,
+# render: true
+def try_except():
+    try:
+        f()
+    except:
+        g()
+    return
+
+# exits: 0,
+# render: true
+def try_except_finally():
+    try:
+        f()
+    except:
+        g()
+    finally:
+        h()
+    return
+
+# exits: 0,
+# render: true
+def try_many_except_finally():
+    try:
+        f()
+    except a:
+        g()
+    except b:
+        aa()
+    except: return
+    finally:
+        h()
+    return
+
+
 # exits: 5,
 # render: true
 def try_finally():
@@ -174,4 +210,5 @@ def try_with_finally():
             return
         pass
     finally:
-        pass
+        pass
+