fix JSON error test expectation for lint changes in rust-lang/rust#38103

[zackmdavis]

Appveyor CI pointed out that rust-lang/rust#38103 (which has been r+'d) breaks Cargo's compiler_json_error_format. I don't know if we have a procedure for coordinating these kinds of changes across repos in a way that CI understands, but ideally, this PR would land here in parallel with rust-lang/rust#38103 in the rust repo.

[rust-highfive]

Thanks for the pull request, and welcome! The Rust team is excited to review your changes, and you should hear from @alexcrichton (or someone else) soon.

If any changes to this PR are deemed necessary, please add them as extra commits. This ensures that the reviewer can see what has changed since they last reviewed the code. Due to the way GitHub handles out-of-date commits, this should also make it reasonably obvious what issues have or haven't been addressed. Large or tricky changes may require several passes of review and changes.

Please see the contribution instructions for more information.

[alexcrichton]

Thanks for the PR! So far the coordination looks like you've figured out. We basically just update Cargo here, then update the submodule, then land the original rust-lang/rust PR.

Unfortunately, though, this PR will have to pass the current test suite of Cargo, which is being run against a compiler without the changes here. That means that as-is we can't land the PR here I believe.

Perhaps we can just relax the test case here? We don't really need to exhaustively check for precisely what the compiler is printing, but from Cargo's perspective we're just testing that something was printed and it was printed to the right place.

[bors]

☔ The latest upstream changes (presumably #3524) made this pull request unmergeable. Please resolve the merge conflicts.

[zackmdavis]

@alexcrichton (force-pushed)

Perhaps we can just relax the test case here? We don't really need to exhaustively check for precisely what the compiler is printing, but from Cargo's perspective we're just testing that something was printed and it was printed to the right place.

... and at least check that the stdout lines are valid JSON? (740088e)

[alexcrichton]

@zackmdavis oh hm I don't think we want to remove all of these assertions, some of them are internal to Cargo itself and we want to continue asserting they're printed correctly. Perhaps just the rustc-specific bits could get ignored?

[zackmdavis]

Maybe ... what makes this really awkward is that the existing execs().with_json() matcher doesn't have any way of ignoring part of a JSON structure (the [..] wildcard functionality is only within strings). Rather than trying to implement JSON-substructure wildcards, I started just using rustc_serialize to pull apart the JSON and make the necessary assertions directly in the compiler_json_error_format test itself (work not committed yet because there are some "borrowed value does not live long enough" errors that I'm too heartbroken and frustrated to look at right now), which should work, but has the drawback of being utterly hideous—

    let stdout = p.cargo_process("build").arg("-v")
        .arg("--message-format").arg("json").exec_with_output()
        .expect("process should succeed").stdout;
    let stdout_lines = stdout.split(|&c| c == ('\n' as u8)).filter(|l| l.len() != 0);

    let bar_message_line = str::from_utf8(stdout_lines.next().unwrap())
        .expect("output should be valid UTF-8");
    let bar_message_object = Json::from_str(bar_message_line)
        .expect("line should be valid JSON").as_object().unwrap();
    assert_eq!("compiler-message", bar_message_object.get("reason").unwrap().as_string().unwrap());
    assert_eq!("bar",
               bar_message_object.get("target").unwrap().as_object().unwrap()
                   .get("name").unwrap().as_string().unwrap());

    let bar_artifact_line = str::from_utf8(stdout_lines.next().unwrap())
        .expect("output should be valid UTF-8");
    let bar_artifact_object = Json::from_str(bar_message_line)
        .expect("line should be valid JSON").as_object().unwrap();
    let expected_bar_artifact_object = Json::from_str(r##"                                                                                                                                      
     {                                                                                                                                                                                          
         "reason":"compiler-artifact",                                                                                                                                                          
         "profile": {                                                                                                                                                                           
             "debug_assertions": true,                                                                                                                                                          
             "debuginfo": true,                                                                                                                                                                 
             "opt_level": "0",                                                                                                                                                                  
             "test": false                                                                                                                                                                      
         },                                                                                                                                                                                     
         "features": [],                                                                                                                                                                        
         "package_id":"bar 0.5.0 ([..])",                                                                                                                                                       
         "target":{"kind":["lib"],"name":"bar","src_path":"[..]lib.rs"},                                                                                                                        
         "filenames":["[..].rlib"]                                                                                                                                                              
     }                                                                                                                                                                                          
"##).unwrap().as_object().unwrap();
    assert_eq!(expected_bar_artifact_object, bar_artifact_object);
// &c.

(I'm kind of upset about my beautiful lint-group-message change being blocked on this much yak-shaving to loosen a test expectation in a completely different repo, but such is the nature of our work, "Patch or STFU" being the whole of the moral law.)

[alexcrichton]

Sorry this is becoming a bit of a yak shave!

We've already got a function comparing two JSON objects, perhaps we could take a hack and say that NaN is equivalent to "any json object here", so it's essentially the equivalent of [..]

[zackmdavis]

out of open-source time this week; will try to take a look at JSON wildcarding (with NaN or some other way) starting Monday night at earliest

[bors]

☔ The latest upstream changes (presumably #3534) made this pull request unmergeable. Please resolve the merge conflicts.

[zackmdavis]

superseded by #3628