Merge pull request #263 from julia-vscode/type-inf-improvements

Type inf improvements

Author: davidanthoff

src/StaticLint.jl

@@ -11,32 +11,11 @@ using SymbolServer: VarRef
 
 const noname = EXPR(:noname, nothing, nothing, 0, 0, nothing, nothing, nothing)
 
-baremodule CoreTypes # Convenience
-using ..SymbolServer
-using Base: ==, @static
-
-const DataType = SymbolServer.stdlibs[:Core][:DataType]
-const Function = SymbolServer.stdlibs[:Core][:Function]
-const Module = SymbolServer.stdlibs[:Core][:Module]
-const String = SymbolServer.stdlibs[:Core][:String]
-const Symbol = SymbolServer.stdlibs[:Core][:Symbol]
-const Int = SymbolServer.stdlibs[:Core][:Int]
-const Float64 = SymbolServer.stdlibs[:Core][:Float64]
-const Vararg = SymbolServer.FakeTypeName(Core.Vararg)
-
-isva(x::SymbolServer.FakeUnionAll) = isva(x.body)
-@static if Core.Vararg isa Core.Type
-    function isva(x)
-        return (x isa SymbolServer.FakeTypeName && x.name.name == :Vararg &&
-            x.name.parent isa SymbolServer.VarRef && x.name.parent.name == :Core)
-    end
-else
-    isva(x) = x isa SymbolServer.FakeTypeofVararg
-end
-end
-
+include("coretypes.jl")
 include("bindings.jl")
 include("scope.jl")
+include("subtypes.jl")
+include("methodmatching.jl")
 
 mutable struct Meta
     binding::Union{Nothing,Binding}
@@ -115,7 +94,7 @@ function (state::Delayed)(x::EXPR)
 
     traverse(x, state)
     if state.scope != s0
-        for (k, b) in state.scope.names
+        for b in values(state.scope.names)
             infer_type_by_use(b, state.server)
             check_unused_binding(b, state.scope)    
         end
@@ -159,7 +138,7 @@ function semantic_pass(file, modified_expr=nothing)
     for x in state.delayed
         if hasscope(x)
             traverse(x, Delayed(scopeof(x), server)) 
-            for (k, b) in scopeof(x).names
+            for b in values(scopeof(x).names)
                 infer_type_by_use(b, state.server)
                 check_unused_binding(b, scopeof(x))
             end

src/bindings.jl

@@ -318,21 +318,22 @@ function add_binding(x, state, scope=state.scope)
                         # Mark as overloaded so that calls to `M.f()` resolve properly.
                         overload_method(tls, b, VarRef(lhs_ref.name, Symbol(name))) # Add to overloaded list but not scope.
                     end
-                elseif lhs_ref isa Binding && lhs_ref.type == CoreTypes.Module
+                elseif lhs_ref isa Binding && CoreTypes.ismodule(lhs_ref.type)
                     if hasscope(lhs_ref.val) && haskey(scopeof(lhs_ref.val).names, name)
                         # Don't need to do anything, name will resolve
                     end
                 end
             else
                 if scopehasbinding(tls, name)
+
                     existing_binding = tls.names[name]
                     if existing_binding isa Binding && (existing_binding.val isa Binding || existing_binding.val isa SymbolServer.FunctionStore || existing_binding.val isa SymbolServer.DataTypeStore)
                         # Should possibly be a while statement
                         # If the .val is as above the Binding likely won't have a proper type attached
                         # so lets use the .val instead.
                         existing_binding = existing_binding.val
                     end
-                    if (existing_binding isa Binding && ((existing_binding.type == CoreTypes.Function || existing_binding.type == CoreTypes.DataType)) || existing_binding isa SymbolServer.FunctionStore || existing_binding isa SymbolServer.DataTypeStore)
+                    if (existing_binding isa Binding && ((CoreTypes.isfunction(existing_binding.type) || CoreTypes.isdatatype(existing_binding.type))) || existing_binding isa SymbolServer.FunctionStore || existing_binding isa SymbolServer.DataTypeStore)
                         # do nothing name of `x` will resolve to the root method
                     else
                         seterror!(x, CannotDefineFuncAlreadyHasValue)
@@ -353,7 +354,7 @@ function add_binding(x, state, scope=state.scope)
             check_const_decl(name, b, scope)
 
             scope.names[name] = b
-        elseif is_soft_scope(scope) && parentof(scope) isa Scope && isidentifier(b.name) && scopehasbinding(parentof(scope), valofid(b.name))
+        elseif is_soft_scope(scope) && parentof(scope) isa Scope && isidentifier(b.name) && scopehasbinding(parentof(scope), valofid(b.name)) && !enforce_hard_scope(x, scope)
             add_binding(x, state, scope.parent)
         else
             scope.names[name] = b
@@ -364,6 +365,10 @@ function add_binding(x, state, scope=state.scope)
     end
 end
 
+function enforce_hard_scope(x::EXPR, scope)
+    scope.expr.head === :for && is_in_fexpr(x, x-> x == scope.expr.args[1])
+end
+
 name_is_getfield(x) = parentof(x) isa EXPR && parentof(parentof(x)) isa EXPR && CSTParser.is_getfield_w_quotenode(parentof(parentof(x)))
 
 
@@ -393,7 +398,7 @@ function mark_globals(x::EXPR, state)
 end
 
 function name_extends_imported_method(b::Binding)
-    if b.type == CoreTypes.Function && CSTParser.hasparent(b.name) && CSTParser.is_getfield(parentof(b.name))
+    if CoreTypes.isfunction(b.type) && CSTParser.hasparent(b.name) && CSTParser.is_getfield(parentof(b.name))
         if refof_maybe_getfield(parentof(b.name)[1]) !== nothing
 
         end

src/coretypes.jl

@@ -0,0 +1,47 @@
+baremodule CoreTypes # Convenience
+using ..SymbolServer
+using Base: ==, @static
+
+const Any = SymbolServer.stdlibs[:Core][:Any]
+const DataType = SymbolServer.stdlibs[:Core][:DataType]
+const Function = SymbolServer.stdlibs[:Core][:Function]
+const Module = SymbolServer.stdlibs[:Core][:Module]
+const String = SymbolServer.stdlibs[:Core][:String]
+const Char = SymbolServer.stdlibs[:Core][:Char]
+const Symbol = SymbolServer.stdlibs[:Core][:Symbol]
+const Bool = SymbolServer.stdlibs[:Core][:Bool]
+const Int = SymbolServer.stdlibs[:Core][:Int]
+const UInt8 = SymbolServer.stdlibs[:Core][:UInt8]
+const UInt16 = SymbolServer.stdlibs[:Core][:UInt16]
+const UInt32 = SymbolServer.stdlibs[:Core][:UInt32]
+const UInt64 = SymbolServer.stdlibs[:Core][:UInt64]
+const Float64 = SymbolServer.stdlibs[:Core][:Float64]
+const Vararg = SymbolServer.FakeTypeName(Core.Vararg)
+
+iscoretype(x, name) = false
+iscoretype(x::SymbolServer.VarRef, name) = x isa SymbolServer.DataTypeStore && x.name.name == name && x.name isa SymbolServer.VarRef && x.name.parent.name == :Core
+iscoretype(x::SymbolServer.DataTypeStore, name) = x isa SymbolServer.DataTypeStore && x.name.name.name == name && x.name.name isa SymbolServer.VarRef && x.name.name.parent.name == :Core
+isdatatype(x) = iscoretype(x, :DataType)
+isfunction(x) = iscoretype(x, :Function)
+ismodule(x) = iscoretype(x, :Module)
+isstring(x) = iscoretype(x, :String)
+ischar(x) = iscoretype(x, :Char)
+issymbol(x) = iscoretype(x, :Symbol)
+@static if Core.Int == Core.Int64
+    isint(x) = iscoretype(x, :Int64)
+else
+    isint(x) = iscoretype(x, :Int32)
+end
+isfloat(x) = iscoretype(x, :Float64)
+isvector(x) = iscoretype(x, :Vector)
+isarray(x) = iscoretype(x, :Array)
+isva(x::SymbolServer.FakeUnionAll) = isva(x.body)
+@static if Core.Vararg isa Core.Type
+    function isva(x)
+        return (x isa SymbolServer.FakeTypeName && x.name.name == :Vararg &&
+            x.name.parent isa SymbolServer.VarRef && x.name.parent.name == :Core)
+    end
+else
+    isva(x) = x isa SymbolServer.FakeTypeofVararg
+end
+end

src/interface.jl

@@ -40,7 +40,7 @@ function lint_file(rootpath, server = setup_server(); gethints = false)
     empty!(server.files)
     root = StaticLint.loadfile(server, rootpath)
     StaticLint.semantic_pass(root)
-    for (p,f) in server.files
+    for f in values(server.files)
         StaticLint.check_all(f.cst, StaticLint.LintOptions(), server)
     end
     if gethints

src/linting/checks.jl

@@ -57,7 +57,7 @@ const LintCodeDescriptions = Dict{LintCodes,String}(IncorrectCallArgs => "Possib
     UnsupportedConstLocalVariable => "Unsupported `const` declaration on local variable.",
     UnassignedKeywordArgument => "Keyword argument not assigned.",
     CannotDefineFuncAlreadyHasValue => "Cannot define function ; it already has a value.",
-    DuplicateFuncArgName => "Function argnument name not unique.",
+    DuplicateFuncArgName => "Function argument name not unique.",
     IncludePathContainsNULL => "Cannot include file, path cotains NULL characters."
     )
 
@@ -260,8 +260,8 @@ function compare_f_call(
 end
 
 function is_something_with_methods(x::Binding)
-    (x.type == CoreTypes.Function && x.val isa EXPR) ||
-    (x.type == CoreTypes.DataType && x.val isa EXPR && CSTParser.defines_struct(x.val)) || # Todo: Could have abstract type with a constructor...
+    (CoreTypes.isfunction(x.type) && x.val isa EXPR) ||
+    (CoreTypes.isdatatype(x.type) && x.val isa EXPR && CSTParser.defines_struct(x.val)) || 
     (x.val isa SymbolServer.FunctionStore || x.val isa SymbolServer.DataTypeStore)
 end
 is_something_with_methods(x::T) where T <: Union{SymbolServer.FunctionStore,SymbolServer.DataTypeStore} = true
@@ -272,18 +272,10 @@ function check_call(x, server)
         parentof(x) isa EXPR && headof(parentof(x)) === :do && return # TODO: add number of args specified in do block.
         length(x.args) == 0 && return
         # find the function we're dealing with
-        if isidentifier(first(x.args)) && hasref(first(x.args))
-            func_ref = refof(first(x.args))
-        elseif is_getfield_w_quotenode(x.args[1]) && (rhs = rhs_of_getfield(x.args[1])) !== nothing && hasref(rhs)
-            func_ref = refof(rhs)
-        else
-            return
-        end
+        func_ref = refof_call_func(x)
+        func_ref === nothing && return
 
-        # if func_ref isa Binding && 
-        # end
-        
-        if (func_ref isa Binding && (func_ref.type === CoreTypes.Function || func_ref.type === CoreTypes.DataType) && !(func_ref.val isa EXPR && func_ref.val.head === :macro)) || func_ref isa SymbolServer.FunctionStore || func_ref isa SymbolServer.DataTypeStore
+        if is_something_with_methods(func_ref) && !(func_ref isa Binding && func_ref.val isa EXPR && func_ref.val.head === :macro)
             # intentionally empty
             if func_ref isa Binding && func_ref.val isa EXPR && isassignment(func_ref.val) && isidentifier(func_ref.val.args[1]) && isidentifier(func_ref.val.args[2])
                 # if func_ref is a shadow binding (for these purposes, an assignment that just changes the name of a mehtod), redirect to the rhs of the assignment.
@@ -438,7 +430,7 @@ function is_never_datatype(b::Binding, server)
         return is_never_datatype(b.val, server)
     elseif b.val isa SymbolServer.FunctionStore
         return is_never_datatype(b.val, server)
-    elseif b.type == CoreTypes.DataType
+    elseif CoreTypes.isdatatype(b.type)
         return false
     elseif b.type !== nothing
         return true
@@ -502,6 +494,10 @@ function check_farg_unused_(arg, arg_names)
         return false
     end
     b = bindingof(arg)
+    
+    # We don't care about these
+    valof(b.name) isa String && all_underscore(valof(b.name)) && return false
+
     if b === nothing ||
         # no refs:
        isempty(b.refs) ||
@@ -633,7 +629,7 @@ end
 function has_getproperty_method(b::Binding)
     if b.val isa Binding || b.val isa SymbolServer.DataTypeStore
         return has_getproperty_method(b.val)
-    elseif b isa Binding && b.type === CoreTypes.DataType
+    elseif b isa Binding && CoreTypes.isdatatype(b.type)
         for ref in b.refs
             if ref isa EXPR && is_type_of_call_to_getproperty(ref)
                 return true
@@ -738,7 +734,10 @@ function check_const_decl(name::String, b::Binding, scope)
         seterror!(b.val, CannotDeclareConst)
     else
         prev = scope.names[name]
-        if (prev.type === CoreTypes.DataType && !is_mask_binding_of_datatype(prev)) || is_const(prev)
+        if (CoreTypes.isdatatype(prev.type) && !is_mask_binding_of_datatype(prev)) || is_const(prev)
+            if b.val isa EXPR && prev.val isa EXPR && !in_same_if_branch(b.val, prev.val)
+                return
+            end
             if b.val isa EXPR
                 seterror!(b.val, InvalidRedefofConst)
             else
@@ -752,12 +751,12 @@ end
 function is_mask_binding_of_datatype(b::Binding)
     b.val isa EXPR && CSTParser.isassignment(b.val) && (rhsref = refof(b.val.args[2])) !== nothing && (rhsref isa SymbolServer.DataTypeStore || (rhsref.val isa EXPR && rhsref.val isa SymbolServer.DataTypeStore) || (rhsref.val isa EXPR && CSTParser.defines_datatype(rhsref.val)))
 end
+
 # check whether a and b are in all the same :if blocks and in the same branches
-function in_same_if_branch(a, b)
-    a_branches = find_if_parents(a)
-    b_branches = find_if_parents(b)
-    
-    return length(a_branches) == length(b_branches) && all(k in keys(b_branches) for k in keys(a_branches)) && all(a_branches[k] == b_branches[k] for k in keys(a_branches))
+in_same_if_branch(a::EXPR, b::EXPR) = in_same_if_branch(find_if_parents(a), find_if_parents(b))
+in_same_if_branch(a::Dict, b::EXPR) = in_same_if_branch(a, find_if_parents(b))
+function in_same_if_branch(a::Dict, b::Dict)
+    return length(a) == length(b) && all(k in keys(b) for k in keys(a)) && all(a[k] == b[k] for k in keys(a))
 end
 
 # find any parent nodes that are :if blocks and a pseudo-index of which branch