Fix BoundsError with mixed file provenance not caused by macros (JuliaLang/JuliaLowering.jl#75)

Was causing several stdlib failures.  MWE:
```
julia> ex = Meta.parse("begin
       x = 111
       x = 222
       end")

JuliaLowering.core_lowering_hook(ex, Main, "foo.jl", 100)
```

If `core_lowering_hook` is given one filename (e.g. "none" from `@eval`), but
     some part of the expression contains LineNumberNodes with a different
     filename, we trigger the "inlined macro-expansion" logic in the debuginfo
     generator, which assumes new filenames are from new macro expansions atop
     the old filename.  The violated invariant is that the list of files in this
     statement's flattened provenance shares some prefix with the last
     statement's list of files.

This fix assumes there is some base file that all statements share, and
     normalizes different base filenames to the first it sees.

Aside: Not sure if this stack logic is 100% correct given that two adjacent
     statements can share arbitrarily many file stack entries despite being from
     different macro expansions.

Author: mlechu

JuliaLowering/src/eval.jl

@@ -79,20 +79,25 @@ end
 
 function add_ir_debug_info!(current_codelocs_stack, stmt)
     locstk = [(filename(e), source_location(e)[1]) for e in flattened_provenance(stmt)]
-    for j in 1:max(length(locstk), length(current_codelocs_stack))
-        if j > length(locstk) || (length(current_codelocs_stack) >= j &&
-                                  current_codelocs_stack[j][1] != locstk[j][1])
-            while length(current_codelocs_stack) >= j
+    for j in 1:length(locstk)
+        if j === 1 && current_codelocs_stack[j][1] != locstk[j][1]
+            # dilemma: the filename stack here shares no prefix with that of the
+            # previous statement, where differing filenames usually (j > 1) mean
+            # a different macro expansion has started at this statement.  guess
+            # that both files are the same, and inherit the previous filename.
+            locstk[j] = (current_codelocs_stack[j][1], locstk[j][2])
+        end
+        if j < length(current_codelocs_stack) && (j === length(locstk) ||
+                current_codelocs_stack[j+1][1] != locstk[j+1][1])
+            while j < length(current_codelocs_stack)
                 info = pop!(current_codelocs_stack)
                 push!(last(current_codelocs_stack)[2], info)
             end
-        end
-        if j > length(locstk)
-            break
         elseif j > length(current_codelocs_stack)
             push!(current_codelocs_stack, (locstk[j][1], [], Vector{Int32}()))
         end
     end
+    @assert length(locstk) === length(current_codelocs_stack)
     for (j, (file,line)) in enumerate(locstk)
         fn, edges, codelocs = current_codelocs_stack[j]
         @assert fn == file

JuliaLowering/test/hooks.jl

@@ -17,6 +17,11 @@ const JL = JuliaLowering
             val = Core.eval(test_mod, out[1])
             @test val == [2,3,4]
         end
+
+        # file argument mismatch with embedded linenumbernodes shouldn't crash
+        ex = Expr(:block, LineNumberNode(111), :(x = 1), LineNumberNode(222), :(x + 1))
+        lwr = JuliaLowering.core_lowering_hook(ex, test_mod, "foo.jl", 333)[1]
+        @test Core.eval(test_mod, lwr) === 2
     end
 
     if isdefined(Core, :_lower)