Add nullability checker

diff --git a/vala/Makefile.am b/vala/Makefile.am
index 397594cdcb178fafe0b9cca714edff88f1f38fb1..80bc3ea1260cdac4f1b64950ef8664baa68da069 100644 (file)
--- a/vala/Makefile.am
+++ b/vala/Makefile.am
@@ -103,6 +103,7 @@ libvalacore_la_VALASOURCES = \
        valamethodtype.vala \
        valanamedargument.vala \
        valanamespace.vala \
+       valanullabilitychecker.vala \
        valanullliteral.vala \
        valanulltype.vala \
        valaobjectcreationexpression.vala \

diff --git a/vala/valabasicblock.vala b/vala/valabasicblock.vala
index 1cdb5a60d355b0e5b6e36706316f25deea12a5d5..51214ac8da49cfa0979354fdd063fb5c1eaca55d 100644 (file)
--- a/vala/valabasicblock.vala
+++ b/vala/valabasicblock.vala
@@ -27,7 +27,7 @@ using GLib;
  * jumps or jump targets.
  */
 public class Vala.BasicBlock {
-       private List<CodeNode> nodes = new ArrayList<CodeNode> ();
+       public List<CodeNode> nodes = new ArrayList<CodeNode> ();
 
        // control flow graph
        private List<weak BasicBlock> predecessors = new ArrayList<weak BasicBlock> ();
@@ -35,7 +35,7 @@ public class Vala.BasicBlock {
 
        // dominator tree
        public BasicBlock parent { get; private set; }
-       List<BasicBlock> children = new ArrayList<BasicBlock> ();
+       public List<BasicBlock> children = new ArrayList<BasicBlock> ();
        Set<BasicBlock> df = new HashSet<BasicBlock> ();
 
        Set<PhiFunction> phi_functions = new HashSet<PhiFunction> ();

diff --git a/vala/valaflowanalyzer.vala b/vala/valaflowanalyzer.vala
index 416144a65844c395206cd15763726a01a11ba04e..4f44177f5794747a691e9726b6ffc64ac96c022c 100644 (file)
--- a/vala/valaflowanalyzer.vala
+++ b/vala/valaflowanalyzer.vala
@@ -227,6 +227,10 @@ public class Vala.FlowAnalyzer : CodeVisitor {
                }
 
                analyze_body (m.entry_block);
+
+               // Now that we built up the CFG, we can actually use it
+               var nullability_checker = new NullabilityChecker (context);
+               nullability_checker.check (m.entry_block);
        }
 
        void analyze_body (BasicBlock entry_block) {

diff --git a/vala/valanullabilitychecker.vala b/vala/valanullabilitychecker.vala
new file mode 100644 (file)
index 0000000..1693145
--- /dev/null
+++ b/vala/valanullabilitychecker.vala
@@ -0,0 +1,123 @@
+
+
+
+public class Vala.NullabilityChecker : CodeVisitor {
+       private const bool debug = false;
+       private CodeContext context;
+       private BasicBlock root_block;
+       private BasicBlock current_block;
+
+
+       public NullabilityChecker (CodeContext context) {
+               this.context = context;
+       }
+
+       public void check (BasicBlock root_block) {
+               this.root_block = root_block;
+               this.current_block = root_block;
+
+               if (debug) {
+                 message ("==========================================");
+                 root_block.print ();
+                 message ("==========================================");
+               }
+               this.visit_basic_block (root_block);
+       }
+
+       private void visit_basic_block (BasicBlock block) {
+               if (debug) {
+                       message ("Checking Basic Block %s (%d nulls, %d non-nulls)",
+                                block.name, block.null_vars.size, block.non_null_vars.size);
+                       message ("Accept() for %d nodes", block.nodes.size);
+               }
+
+               this.current_block = block;
+
+               foreach (var node in block.nodes) {
+                       //message ("Accept() ing %s", node.type_name);
+                       node.accept (this);
+               }
+
+               foreach (var child in block.children) {
+                       visit_basic_block (child);
+               }
+
+
+               // TODO: reset current_block ???
+       }
+
+       public override void visit_member_access (MemberAccess access) {
+               if (debug)
+                       message ("Checking Member Access %s", access.to_string ());
+               if (access.inner != null) {
+                       if (debug)
+                               message ("Inner: %s", access.inner.to_string ());
+                       bool is_null = false;
+                       bool is_non_null = false;
+                       BasicBlock? b = current_block;
+                       while (b != null) {
+                               if (b.null_vars.contains (access.inner.symbol_reference)) {
+                                       is_null = true;
+                                       break;
+                               } else if (b.non_null_vars.contains (access.inner.symbol_reference)) {
+                                       is_non_null = true;
+                                       break;
+                               }
+                               b = b.parent;
+                       }
+
+                       if (is_null) {
+                               Report.error (access.source_reference, "`%s' is null here".printf (access.to_string ()));
+                       } else if (access.inner.symbol_reference != null) {
+                               DataType? symbol_type = context.analyzer.get_value_type_for_symbol (access.inner.symbol_reference, false);
+                               if (symbol_type != null) {
+                                       // If the referenced type is nullable, and the code didn't make sure the reference
+                                       // is not null, we need to error out here.
+                                       if (symbol_type.nullable && !is_non_null) {
+                                               Report.error (access.source_reference, "Access to nullable reference `%s' denied".printf (access.inner.symbol_reference.get_full_name ()));
+                                       }
+                               }
+                       }
+               }
+
+               access.accept_children (this);
+       }
+
+       public override void visit_declaration_statement (DeclarationStatement decl) {
+               decl.accept_children (this);
+       }
+
+       public override void visit_source_file (SourceFile source_file) {
+               source_file.accept_children (this);
+       }
+
+       public override void visit_class (Class cl) {
+               cl.accept_children (this);
+       }
+
+       public override void visit_struct (Struct st) {
+               st.accept_children (this);
+       }
+
+       public override void visit_interface (Interface iface) {
+               iface.accept_children (this);
+       }
+
+       public override void visit_enum (Enum en) {
+               en.accept_children (this);
+       }
+
+       public override void visit_error_domain (ErrorDomain ed) {
+               ed.accept_children (this);
+       }
+
+       public override void visit_method (Method m) {
+               m.accept_children (this);
+       }
+
+       public override void visit_local_variable (LocalVariable local) {
+               if (local.initializer != null) {
+                       local.initializer.accept (this);
+               }
+       }
+}