sql-typechecker 0.0.12 → 0.0.13

package/out/cli.js

@@ -206264,7 +206264,7 @@ ${frame}`;
   var require_comments = __commonJS22({
     "src/main/comments.js"(exports22, module22) {
       "use strict";
-      var assert = require("assert");
+      var assert2 = require("assert");
       var {
         builders: {
           line,
@@ -206554,8 +206554,8 @@ ${frame}`;
             precedingNode: currentCommentPrecedingNode,
             followingNode: currentCommentFollowingNode
           } = tiesToBreak[indexOfFirstLeadingComment - 1];
-          assert.strictEqual(currentCommentPrecedingNode, precedingNode);
-          assert.strictEqual(currentCommentFollowingNode, followingNode);
+          assert2.strictEqual(currentCommentPrecedingNode, precedingNode);
+          assert2.strictEqual(currentCommentFollowingNode, followingNode);
           const gap = text.slice(options.locEnd(comment), gapEndPos);
           if (gapRegExp.test(gap)) {
             gapEndPos = options.locStart(comment);
@@ -207042,7 +207042,7 @@ ${frame}`;
   var require_range_util = __commonJS22({
     "src/main/range-util.js"(exports22, module22) {
       "use strict";
-      var assert = require("assert");
+      var assert2 = require("assert");
       var comments = require_comments();
       var isJsonParser = ({
         parser
@@ -207158,7 +207158,7 @@ ${frame}`;
           locStart,
           locEnd
         } = opts;
-        assert.ok(end > start);
+        assert2.ok(end > start);
         const firstNonWhitespaceCharacterIndex = text.slice(start, end).search(/\S/);
         const isAllWhitespace = firstNonWhitespaceCharacterIndex === -1;
         if (!isAllWhitespace) {
@@ -225014,7 +225014,7 @@ ${fromBody}`;
   var require_function = __commonJS22({
     "src/language-js/print/function.js"(exports22, module22) {
       "use strict";
-      var assert = require("assert");
+      var assert2 = require("assert");
       var {
         printDanglingComments,
         printCommentsSeparately
@@ -225119,7 +225119,7 @@ ${fromBody}`;
             parts.push("async ");
           }
         } else {
-          assert.ok(kind === "get" || kind === "set");
+          assert2.ok(kind === "get" || kind === "set");
           parts.push(kind, " ");
         }
         if (value2.generator) {
@@ -226022,7 +226022,7 @@ ${fromBody}`;
   var require_flow = __commonJS22({
     "src/language-js/print/flow.js"(exports22, module22) {
       "use strict";
-      var assert = require("assert");
+      var assert2 = require("assert");
       var {
         printDanglingComments
       } = require_comments();
@@ -226198,7 +226198,7 @@ ${fromBody}`;
             const {
               kind
             } = node;
-            assert.ok(kind === "plus" || kind === "minus");
+            assert2.ok(kind === "plus" || kind === "minus");
             return kind === "plus" ? "+" : "-";
           }
           case "ObjectTypeCallProperty":
@@ -226231,7 +226231,7 @@ ${fromBody}`;
           case "StringLiteralTypeAnnotation":
             return printString(rawText(node), options);
           case "NumberLiteralTypeAnnotation":
-            assert.strictEqual(typeof node.value, "number");
+            assert2.strictEqual(typeof node.value, "number");
           case "BigIntLiteralTypeAnnotation":
             if (node.extra) {
               return printNumber(node.extra.raw);
@@ -226299,7 +226299,7 @@ ${fromBody}`;
       function printFlowDeclaration(path2, printed) {
         const parentExportDecl = getParentExportDeclaration(path2);
         if (parentExportDecl) {
-          assert.strictEqual(parentExportDecl.type, "DeclareExportDeclaration");
+          assert2.strictEqual(parentExportDecl.type, "DeclareExportDeclaration");
           return printed;
         }
         return ["declare ", printed];
@@ -233598,7 +233598,7 @@ ${extracted.content}`;
   var require_tag = __commonJS22({
     "src/language-html/print/tag.js"(exports22, module22) {
       "use strict";
-      var assert = require("assert");
+      var assert2 = require("assert");
       var {
         isNonEmptyArray
       } = require_util();
@@ -233642,7 +233642,7 @@ ${extracted.content}`;
         return needsToBorrowParentClosingTagStartMarker(node) ? printClosingTagStartMarker(node.parent, options) : needsToBorrowNextOpeningTagStartMarker(node) ? printOpeningTagStartMarker(node.next) : "";
       }
       function printClosingTagStartMarker(node, options) {
-        assert(!node.isSelfClosing);
+        assert2(!node.isSelfClosing);
         if (shouldNotPrintClosingTag(node, options)) {
           return "";
         }
@@ -233760,7 +233760,7 @@ ${extracted.content}`;
         }
       }
       function printOpeningTagEndMarker(node) {
-        assert(!node.isSelfClosing);
+        assert2(!node.isSelfClosing);
         switch (node.type) {
           case "ieConditionalComment":
             return "]>";
@@ -235901,6 +235901,7 @@ var import_pgsql_ast_parser2 = __toModule(require_lib());
 var prettier = __toModule(require_prettier());
 
 // src/typecheck.ts
+var import_assert = __toModule(require("assert"));
 var import_pgsql_ast_parser = __toModule(require_lib());
 
 // src/normalize.ts
@@ -242017,7 +242018,24 @@ function deriveNameFromExpr(expr) {
 }
 function elabSelect(g, c, s) {
   if (s.type === "select") {
-    const newC = addFromsToScope(g, c, s, s.from || []);
+    const newC = (() => {
+      const newC_ = addFromsToScope(g, c, s, s.from || []);
+      const inferredNullability = s.where ? inferNullability(newC_, s.where) : [];
+      return {
+        ...newC_,
+        froms: newC_.froms.map((fr) => ({
+          name: fr.name,
+          type: {
+            kind: "record",
+            fields: fr.type.fields.map((fi) => {
+              const foundNullabilityInference = inferredNullability.find((inf) => eqQNames(inf.fromName, fr.name) && inf.fieldName === fi.name?.name);
+              const t = foundNullabilityInference ? foundNullabilityInference.isNull === true ? nullify(fi.type) : unnullify(fi.type) : fi.type;
+              return {name: fi.name, type: t};
+            })
+          }
+        }))
+      };
+    })();
     if (s.where) {
       const t = elabExpr(g, newC, s.where);
       requireBoolean(s.where, t);
@@ -242231,6 +242249,9 @@ function doCreateFunction(g, c, s) {
   if (!s.language) {
     throw new Error("Please provide language for function at " + showLocation(s._location));
   }
+  if (s.code === void 0) {
+    throw new ErrorWithLocation(s._location, "Function definition without body");
+  }
   if (s.language && s.language.name.toLowerCase() === "sql") {
     const inputs = s.arguments.map((arg) => {
       if (!arg.name) {
@@ -242580,45 +242601,66 @@ function elabRef(c, e) {
       };
     }
   } else {
-    const tableName = e.table;
-    if (tableName) {
-      const table = c.froms.find((d) => eqQNames(d.name, tableName));
-      if (!table) {
-        throw new UnknownIdentifier(e, tableName);
-      }
-      if (!(table.type.kind === "record")) {
-        throw new KindMismatch(e, table.type, "Expecting Record");
+    const found = lookupRef(c, e);
+    if (found instanceof Error) {
+      throw found;
+    } else {
+      return found.type;
+    }
+  }
+}
+function lookupRef(c, e) {
+  import_assert.default(e.name !== "*");
+  const tableName = e.table;
+  if (tableName) {
+    const table = c.froms.find((d) => eqQNames(d.name, tableName));
+    if (!table) {
+      return new UnknownIdentifier(e, tableName);
+    }
+    if (!(table.type.kind === "record")) {
+      return new KindMismatch(e, table.type, "Expecting Record");
+    }
+    const field = lookupInRecord(table.type, e);
+    if (!field) {
+      return new UnknownField(e, table.type, e);
+    }
+    return {
+      type: field,
+      from: {
+        fromName: tableName,
+        fieldName: e.name
       }
-      const field = lookupInRecord(table.type, e);
-      if (!field) {
-        throw new UnknownField(e, table.type, e);
+    };
+  } else {
+    const foundFields = mapPartial(c.froms, (t) => {
+      const foundfield = lookupInRecord(t.type, e);
+      return foundfield ? {fromName: t.name, field: e, type: foundfield} : null;
+    });
+    const foundIdentifiers = mapPartial(c.decls, (t) => {
+      if (t.type.kind === "record" || t.type.kind === "void") {
+        return null;
+      } else {
+        return t.name.name === e.name ? {name: t.name.name, type: t.type} : null;
       }
-      return field;
-    } else {
-      const foundFields = mapPartial(c.froms, (t) => {
-        const foundfield = lookupInRecord(t.type, e);
-        return foundfield ? {record: t.name, field: e, type: foundfield} : null;
-      });
-      const foundIdentifiers = mapPartial(c.decls, (t) => {
-        if (t.type.kind === "record" || t.type.kind === "void") {
-          return null;
-        } else {
-          return t.name.name === e.name ? {name: t.name.name, type: t.type} : null;
-        }
-      });
-      if (foundFields.length === 0) {
-        if (foundIdentifiers.length === 0) {
-          throw new UnknownIdentifier(e, e);
-        } else if (foundIdentifiers.length === 1) {
-          return foundIdentifiers[0].type;
-        } else {
-          throw new AmbiguousIdentifier(e, e, []);
-        }
-      } else if (foundFields.length === 1) {
-        return foundFields[0].type;
+    });
+    if (foundFields.length === 0) {
+      if (foundIdentifiers.length === 0) {
+        return new UnknownIdentifier(e, e);
+      } else if (foundIdentifiers.length === 1) {
+        return {type: foundIdentifiers[0].type, from: null};
       } else {
-        throw new AmbiguousIdentifier(e, e, foundFields.map((f) => f.record));
+        return new AmbiguousIdentifier(e, e, []);
       }
+    } else if (foundFields.length === 1) {
+      return {
+        type: foundFields[0].type,
+        from: {
+          fromName: foundFields[0].fromName,
+          fieldName: foundFields[0].field.name
+        }
+      };
+    } else {
+      return new AmbiguousIdentifier(e, e, foundFields.map((f) => f.fromName));
     }
   }
 }
@@ -243016,6 +243058,37 @@ function elabExpr(g, c, e) {
     return checkAllCasesHandled(e.type);
   }
 }
+function inferNullability(c, e) {
+  if (e.type === "unary") {
+    if (e.op === "NOT") {
+      return inferNullability(c, e).map((judg) => ({
+        ...judg,
+        isNull: !judg.isNull
+      }));
+    }
+    if (e.op === "IS NULL" || e.op === "IS NOT NULL") {
+      if (e.operand.type === "ref") {
+        const found = lookupRef(c, e.operand);
+        if (found instanceof Error) {
+          return [];
+        } else {
+          if (found.from === null) {
+            return [];
+          } else {
+            return [
+              {...found.from, isNull: e.op === "IS NULL" ? true : false}
+            ];
+          }
+        }
+      }
+    }
+    return [];
+  } else if (e.type === "binary" && e.op === "AND") {
+    return inferNullability(c, e.left).concat(inferNullability(c, e.right));
+  } else {
+    return [];
+  }
+}
 function elabStatement(g, c, s) {
   if (s.type === "select" || s.type === "union" || s.type === "union all" || s.type === "with" || s.type === "with recursive" || s.type === "values") {
     return elabExpr(g, c, s);