Fix result of catch null and catch return null

Author: frmdstryr

duchain/expressionvisitor.cpp

@@ -1677,7 +1677,22 @@ VisitResult ExpressionVisitor::visitCatch(const ZigNode &node, const ZigNode &pa
     v.startVisiting(lhs, node);
     // TODO: Check that lhs and rhs are compatable
     if (auto errorType = v.lastType().dynamicCast<ErrorType>()) {
-        encounter(errorType->baseType());
+        ZigNode rhs = {node.ast, data.rhs};
+        ExpressionVisitor v2(this);
+        v2.startVisiting(rhs, node);
+
+        auto baseType = errorType->baseType();
+
+        // Make type optional if it has catch null but not catch return null
+        if (auto builtin = v2.exprType().dynamicCast<BuiltinType>()) {
+            if (!v2.returnType() && builtin->isNull() && !baseType.dynamicCast<OptionalType>()) {
+                OptionalType::Ptr result(new OptionalType());
+                result->setBaseType(baseType);
+                encounter(result);
+                return Continue;
+            }
+        }
+        encounter(baseType);
     } else {
         encounterUnknown(); // TODO: Show error?
     }

duchain/expressionvisitor.h

@@ -15,6 +15,7 @@
 #include "zignode.h"
 #include "zigdebug.h"
 #include "parsesession.h"
+#include "types/builtintype.h"
 
 namespace Zig
 {
@@ -167,6 +168,18 @@ class KDEVZIGDUCHAIN_EXPORT ExpressionVisitor : public KDevelop::DynamicLanguage
         return m_breakType;
     }
 
+    /**
+     * If a break or return was encountered this returns the BuiltinType "void"
+     * otherwise, return the result of the last expression encountered.
+     */
+    const KDevelop::AbstractType::Ptr exprType() const {
+        if (m_returnType || m_breakType) {
+            return BuiltinType::newFromName(QLatin1String("void"));
+        }
+        return lastType();
+    }
+
+
     void setExcludedDeclaration(const KDevelop::Declaration* d) {
         m_excludedDeclaration = d;
     }

duchain/tests/duchaintest.cpp

@@ -677,6 +677,8 @@ void DUChainTest::testVarType_data()
         << "const WriteError = error{EndOfStream};\n"
            "pub fn write() WriteError!void {}\n"
            "test{write() catch |err| {\n}}" << "err" << "WriteError" << "3,0";
+    QTest::newRow("catch null") << "pub fn foo() !u8 { return 0; }; var x = foo() catch null;" << "x" << "?u8" << "";
+    QTest::newRow("catch return null") << "pub fn foo() !u8 { return 0; }; var x = foo() catch return null;" << "x" << "u8" << "";
 
     QTest::newRow("labelled block") << "const x = blk: { break :blk true; };" << "x" << "bool = true" << "";
 
@@ -947,7 +949,7 @@ void DUChainTest::testProblems_data()
     // QTest::newRow("catch return 2") << "pub fn write(msg: []const u8) !usize { return 0; } pub fn main() void { const x = write(\"abcd\") catch |err| { if (true) { return; } return err; }; }" << QStringList{} << "";
     QTest::newRow("catch no return") << "pub fn write(msg: []const u8) !usize { return 0; } pub fn main() void { const x = write(\"abcd\") catch { }; }" << QStringList{QLatin1String("Incompatible types")} << "";
     QTest::newRow("catch panic") << "pub fn write(msg: []const u8) !usize { return 0; } pub fn main() void { const x = write(\"abcd\") catch @panic(\"doom\"); }" << QStringList{} << "";
-
+    QTest::newRow("catch return null") << "const Obj = struct{}; pub fn new() !*Obj { return error.OutOfMem; } pub fn init() ?*Obj { return new() catch null; } test { const x = init();}" << QStringList{} << "";
 
     QTest::newRow("struct field") << "const A = struct {a: u8}; test {const x = A{.a = 0}; }" << QStringList{} << "";
     QTest::newRow("struct field type invalid") << "const A = struct {a: u8}; test {const x = A{.a = false}; }" << QStringList{QLatin1String("type mismatch")} << "";

duchain/usebuilder.cpp

@@ -918,14 +918,14 @@ VisitResult UseBuilder::visitCatch(const ZigNode &node, const ZigNode &parent)
         if (Helper::isMixedType(v2.lastType())) {
             return Continue;
         }
+        auto targetType = errorType->baseType();
+
         if (auto builtin = v2.lastType().dynamicCast<BuiltinType>()) {
-            if (builtin->isTrap()) {
-                return Continue; // Ignore foo() catch @panic()
+            if (builtin->isTrap() || builtin->isNull()) {
+                return Continue; // Ignore foo() catch @panic() or catch null
             }
         }
 
-
-        auto targetType = errorType->baseType();
         // TODO: Determining whether the target is const should be done better,
         // this only works for a single case of const foo = a catch b;
         if (parent.kind() == VarDecl && parent.mainToken() == QStringLiteral("const")) {