« first day (1574 days earlier)      last day (1606 days later) » 
00:00 - 14:0014:00 - 23:00

12:00 AM
RELOAD!
[rubberduck-vba/Rubberduck] 1 closed issue. 11 issue comments.
[Zomis/Server2] 1 commit. 458 additions. 20 deletions.
 
woopsie, "smart concat" doesn't look so smart anymore
 
12:56 AM
@MathieuGuindon Looking at #4339. Was the intention to check to see if AC was enabled in the Execute methods, or stop the events from being raised?
 
disabled AC should completely stop any interfering with anything that could happen in the code pane
 
OK. I should probably just check to see if ApplyAutoCompleteSettings is being called and take it from there.
Well, there's the problem. OnSettingsChanged(new ConfigurationChangedEventArgs(inspectOnReparse, langChanged, inspectionsChanged, autoCompletesChanged));
The event is never being raised.
 
1:21 AM
WTH is this commented out?
    private void ConfigServiceSettingsChanged(object sender, EventArgs e)
    {
        //var config = _configService.LoadConfiguration();
        //UpdateInspectionSeverity(config);
    }
 
1:37 AM
huh, that doesn't look right, wherever it's at
 
That's in the inspections.
 
how... how do inspection severity levels update then? (because they do!)
 
Does AutoCompleteService need to be tied into RubberduckHooks? ApplyAutoCompleteSettings is getting called repeatedly, and RubberduckHooks calls both ApplyAutoCompleteSettings and Enable or Disable.
@MathieuGuindon That's a really good question.
 
@Comintern TBH I'm not sure what the best approach is here... I just went with whatever seemed to work
 
Hmmm... The WMs we care about are window specific, so I'm not sure we need to enable\disable them on focus changes.
What I can't figure out is why the ctor isn't running.
Oh wait, NVM. I missed with the break point. :facepalm:
 
1:49 AM
lol
in other news, everything smart-concat starts off beautifully
foo = "|"
hit ENTER, and mid-point through the method, code becomes:
foo = "" & _
      ""
#sofarsogood
hey wait a minute
I don't know how I wrecked it before
oh I think I know
IsInsideStringLiteral isn't accounting for escaped double-quotes
 
...which actually makes sense - you don't split a line at "|" when "" is escaping "
 
Ahhh....
There's a string literal escaper class in the indenter for parsing those.
 
I honestly can't repro the wrecking that happened earlier
that's annoying.. I bet @ThunderFrame will find a way to break it within minutes
 
When I was messing around with it a couple minutes ago, it was solid as a rock.
 
1:59 AM
awesome :)
 
Oh wait, I think there was one thing. Given this: MsgBox "|, typing the closing double-quote gives this: MsgBox """|
 
given MsgBox "| typing the closing double-quote gives me MsgBox ""|"" here (wonder what's right in this case..)
I'd expect MsgBox ""| I think
 
I would too.
That gives me a feature idea...
Given "|" (or any selection inside a string literal), pasting should auto escape " to "" in the pasted string.
 
I'm completely ignoring the case where the closing char is the same as the opening char and the input means to be the closing char
 
[rubberduck-vba/Rubberduck] build for commit 19ebfb92 on unknown branch: AppVeyor build succeeded
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4389?src=pr&el=h1) Report
> Merging [#4389](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4389?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/6df939d9edd3dd3f129f74996e6936f3c880e6da?src=pr&el=desc) will **increase** coverage by `<.01%`.
> The diff coverage is `0%`.


```diff
@@ Coverage Diff @@
## next #4389 +/- ##
===========================
 
2:04 AM
I think I can write a failing test for that
 
[rubberduck-vba/Rubberduck] build for commit 19ebfb92 on unknown branch: 57.76% (target 0%)
 
Gotta add that assert for the offbyone too
 
WTH? MsgBox """| then down arrow gives MsgBox """". Is that the VBE?
 
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4389?src=pr&el=h1) Report
> Merging [#4389](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4389?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/6df939d9edd3dd3f129f74996e6936f3c880e6da?src=pr&el=desc) will **increase** coverage by `<.01%`.
> The diff coverage is `0%`.


```diff
@@ Coverage Diff @@
## next #4389 +/- ##
===========================
 
2:07 AM
@Duga More deletes than adds apparently increases coverage. Yay!
 
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=h1) Report
> Merging [#4387](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/49d5bfb9e9d3e92e4a80acdb2af68123827bbf02?src=pr&el=desc) will **increase** coverage by `0.07%`.
> The diff coverage is `38.28%`.


```diff
@@ Coverage Diff @@
## next #4387 +/- ##
=======================
 
DeletingOpeningCharRemovesPairedClosingChar_NestedParensMultiline passing and not repro'd in the VBE annoys me to no end
gotta be something about SnippetPosition
 
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=h1) Report
> Merging [#4387](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/49d5bfb9e9d3e92e4a80acdb2af68123827bbf02?src=pr&el=desc) will **increase** coverage by `0.07%`.
> The diff coverage is `38.28%`.


```diff
@@ Coverage Diff @@
## next #4387 +/- ##
=======================
 
@Duga added two tests, expected one to fail - both do
 
2:18 AM
facepalm I'm such a moron
 
both tests fail because the SCP result is null (aka default)
which means SCP is leaving the input alone
....as it should
 
[rubberduck-vba/Rubberduck] build for commit e49c42ec on unknown branch: AppVeyor build succeeded
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=h1) Report
> Merging [#4387](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/49d5bfb9e9d3e92e4a80acdb2af68123827bbf02?src=pr&el=desc) will **increase** coverage by `0.07%`.
> The diff coverage is `37.98%`.


```diff
@@ Coverage Diff @@
## next #4387 +/- ##
=======================
[rubberduck-vba/Rubberduck] build for commit e49c42ec on unknown branch: 57.84% (target 0%)
 
...which means MsgBox "| with " input should effectively give us MsgBox ""|
 
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=h1) Report
> Merging [#4387](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/49d5bfb9e9d3e92e4a80acdb2af68123827bbf02?src=pr&el=desc) will **increase** coverage by `0.07%`.
> The diff coverage is `37.98%`.


```diff
@@ Coverage Diff @@
## next #4387 +/- ##
=======================
 
2:23 AM
duh, " test was using ) for input
#CopyPasta
 
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=h1) Report
> Merging [#4387](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/49d5bfb9e9d3e92e4a80acdb2af68123827bbf02?src=pr&el=desc) will **increase** coverage by `0.07%`.
> The diff coverage is `37.98%`.


```diff
@@ Coverage Diff @@
## next #4387 +/- ##
=======================
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=h1) Report
> Merging [#4387](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/49d5bfb9e9d3e92e4a80acdb2af68123827bbf02?src=pr&el=desc) will **increase** coverage by `0.07%`.
> The diff coverage is `37.98%`.


```diff
@@ Coverage Diff @@
## next #4387 +/- ##
=======================
 
ok, fails as expected
 
That reminds me. When I was searching for Assert.Succeed in the chat history I noticed that the word "succeed` gives 2 pages of results. "fail" gives 19 (and counting).
 
@Comintern does pick up @Duga screaming a blown build?
 
2:30 AM
AppVeyor build failed: 899 messages found.
1.4% of those were in the last week.
 
AppVeyor build succeeded: 4,101 4,102 results
 
82% successful build rate isn't that bad.
 
[rubberduck-vba/Rubberduck] build for commit 42df73c6 on unknown branch: AppVeyor build failed
BUILD FAILURE!
 
I don't like this
if (input == pair.OpeningChar && pair.ClosingChar != pair.OpeningChar || original.Code[original.CaretPosition.StartColumn - 1] != pair.OpeningChar)
 
Too verbose?
 
2:42 AM
yeah, and wrong too
test is still failing
and frail - will blow up with out-of-range depending on what original.Code is
 
What condition is the test for?
 
        [Test]
        public void GivenClosingCharForUnmatchedOpeningChar_MatchedPairOnlyAddsClosingChar()
        {
            var pair = new SelfClosingPair('"', '"');
            var input = '"';
            var original = "MsgBox \"|".ToCodeString();

            var result = Run(pair, original, input);
            Assert.IsNull(result);
        }
 
[rubberduck-vba/Rubberduck] build for commit 6f8871e9 on unknown branch: AppVeyor build failed
BUILD FAILURE!
 
hmm, test name isn't ideal
        [Test]
        public void GivenClosingCharForUnmatchedOpeningChar_MatchedPairBailsOut()
        {
            var pair = new SelfClosingPair('"', '"');
            var input = '"';
            var original = "MsgBox \"|".ToCodeString();

            var result = Run(pair, original, input);
            Assert.IsNull(result);
        }
#ThereFixedIt
            var handleAsClosing = pair.IsSymetric &&
                                  original.Code.Length >= 1 &&
                                  original.Code[original.CaretPosition.StartColumn - 1] == pair.ClosingChar;

            if (input == pair.OpeningChar && !handleAsClosing)
better already
 
What about something along these lines?
    private static bool InsidePair(this char[] code, char starting, char ending, int caret)
    {
        Debug.Assert(caret <= code.Length && caret >= 0);
        var opens = code.Take(caret).Count(character => character == starting || character == ending);
        var closes = code.Skip(caret).Count(character => character == starting || character == ending);
        return opens == closes;
    }
^ That's probably wrong.
More than probably wrong. Is wrong.
 
2:54 AM
I got handleAsClosing=true
#babysteps
ok, HandleClosingChar needs to special-case "symetric" pairs
..or not - handleAsClosing being true is all I need to know
bingo
 
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=h1) Report
> Merging [#4387](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/49d5bfb9e9d3e92e4a80acdb2af68123827bbf02?src=pr&el=desc) will **increase** coverage by `0.07%`.
> The diff coverage is `37.98%`.


```diff
@@ Coverage Diff @@
## next #4387 +/- ##
=======================
 
I think we're good
 
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=h1) Report
> Merging [#4387](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/49d5bfb9e9d3e92e4a80acdb2af68123827bbf02?src=pr&el=desc) will **increase** coverage by `0.07%`.
> The diff coverage is `37.98%`.


```diff
@@ Coverage Diff @@
## next #4387 +/- ##
=======================
 
F5-testing now
bee you tee full
@Comintern saw my reply comment?
> it's effectively dangling. didn't think it mattered, since I'm re-joining later using \n... or does it?
 
Damnit, stupid test setup.
@MathieuGuindon I wasn't sure if it mattered or not. It would make the lines one character longer.
I do this in the indenter: var codeLines = module.GetLines(1, lineCount).Replace("\r", string.Empty).Split('\n');
I'm trying to remember why though.
 
3:07 AM
oh good. was going to add some LINQ - .Replace is better
 
I think it might have been because of something in the spec that you'd never run across IRL.
 
[rubberduck-vba/Rubberduck] build for commit 4dcbe788 on unknown branch: AppVeyor build succeeded
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=h1) Report
> Merging [#4387](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/49d5bfb9e9d3e92e4a80acdb2af68123827bbf02?src=pr&el=desc) will **increase** coverage by `0.08%`.
> The diff coverage is `40.3%`.


```diff
@@ Coverage Diff @@
## next #4387 +/- ##
========================
[rubberduck-vba/Rubberduck] build for commit 4dcbe788 on unknown branch: 57.85% (target 0%)
 
adding a protected set to Code in CodeString makes R# complain about Code being used to compute the hashcode... should we worry?
 
WTH? Are the serialized declarations busted again?
 
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=h1) Report
> Merging [#4387](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/49d5bfb9e9d3e92e4a80acdb2af68123827bbf02?src=pr&el=desc) will **increase** coverage by `0.08%`.
> The diff coverage is `40.3%`.


```diff
@@ Coverage Diff @@
## next #4387 +/- ##
========================
 
3:12 AM
@MathieuGuindon Is it over-ridden? I'm not sure I get R#'s beef there.
 
the property isn't technically immutable, that's why
 
Ah. Is it a struct?
 
had to make it a class to make TestCodeString inherit CodeString
...that said I can't find a usage for the protected setter.. wtf
removed
 
    var interestingDeclarations =
        State.AllDeclarations.Where(item =>
            item.AsTypeDeclaration != null
            && ClassModuleDeclaration.HasDefaultMember(item.AsTypeDeclaration));
 
3:15 AM
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=h1) Report
> Merging [#4387](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/49d5bfb9e9d3e92e4a80acdb2af68123827bbf02?src=pr&el=desc) will **increase** coverage by `0.08%`.
> The diff coverage is `40.3%`.


```diff
@@ Coverage Diff @@
## next #4387 +/- ##
========================
 
^ No results with Excel's serialized declarations.
That explains why there are zero tests...
 
[rubberduck-vba/Rubberduck] build for commit b2c41828 on unknown branch: AppVeyor build succeeded
 
default members have been flaky for ~2 years :)
 
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=h1) Report
> Merging [#4387](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/49d5bfb9e9d3e92e4a80acdb2af68123827bbf02?src=pr&el=desc) will **increase** coverage by `0.08%`.
> The diff coverage is `40.3%`.


```diff
@@ Coverage Diff @@
## next #4387 +/- ##
========================
[rubberduck-vba/Rubberduck] build for commit b2c41828 on unknown branch: 57.85% (target 0%)
[rubberduck-vba/Rubberduck] build for commit a83c846a on unknown branch: AppVeyor build failed
BUILD FAILURE!
 
@MathieuGuindon Works fine when they're read from the tlb. That can only really be something in the deserialization.
 
3:19 AM
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=h1) Report
> Merging [#4387](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/49d5bfb9e9d3e92e4a80acdb2af68123827bbf02?src=pr&el=desc) will **increase** coverage by `0.08%`.
> The diff coverage is `40.3%`.


```diff
@@ Coverage Diff @@
## next #4387 +/- ##
========================
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=h1) Report
> Merging [#4387](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/49d5bfb9e9d3e92e4a80acdb2af68123827bbf02?src=pr&el=desc) will **increase** coverage by `0.08%`.
> The diff coverage is `40.3%`.


```diff
@@ Coverage Diff @@
## next #4387 +/- ##
========================
> Noticed this when I was writing the (missing) tests for #4327. Given a test setup that uses the Excel reference, this code...

```
var interestingDeclarations =
State.AllDeclarations.Where(item =>
item.AsTypeDeclaration != null
&& ClassModuleDeclaration.HasDefaultMember(item.AsTypeDeclaration));
```
...returns no results. The declarations collected from the typelib are fine.
 
nice catch
 
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4389?src=pr&el=h1) Report
> Merging [#4389](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4389?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/6df939d9edd3dd3f129f74996e6936f3c880e6da?src=pr&el=desc) will **increase** coverage by `<.01%`.
> The diff coverage is `0%`.


```diff
@@ Coverage Diff @@
## next #4389 +/- ##
===========================
[rubberduck-vba/Rubberduck] build for commit efb5ea3e on unknown branch: AppVeyor build succeeded
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=h1) Report
> Merging [#4387](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/49d5bfb9e9d3e92e4a80acdb2af68123827bbf02?src=pr&el=desc) will **increase** coverage by `0.08%`.
> The diff coverage is `40.88%`.


```diff
@@ Coverage Diff @@
## next #4387 +/- ##
=======================
[rubberduck-vba/Rubberduck] build for commit efb5ea3e on unknown branch: 57.85% (target 0%)
 
well there's the problem
original only contains the current line
I need it to contain the current instruction
no
 
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=h1) Report
> Merging [#4387](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/49d5bfb9e9d3e92e4a80acdb2af68123827bbf02?src=pr&el=desc) will **increase** coverage by `0.08%`.
> The diff coverage is `40.88%`.


```diff
@@ Coverage Diff @@
## next #4387 +/- ##
=======================
 
it contains the current physical line, and I need it to be the current logical line
that's a tough cookie
 
3:30 AM
> Linking chat. This is likely a much wider issue than just this dialog.
 
ok trying something
 
@MathieuGuindon That's a largely solved cookie. What about modifying the SmartIndenter objects? It already parses LogicalCodeLines and AbsoluteCodeLines. Those could be generalized.
 
hmm
it's massively indenter-specific at this point though
 
[rubberduck-vba/Rubberduck] build for commit 90c5c51a on unknown branch: AppVeyor build succeeded
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4389?src=pr&el=h1) Report
> Merging [#4389](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4389?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/6df939d9edd3dd3f129f74996e6936f3c880e6da?src=pr&el=desc) will **increase** coverage by `0.06%`.
> The diff coverage is `57.14%`.


```diff
@@ Coverage Diff @@
## next #4389 +/- ##
=======================
 
Yeah, they're probably a bit heavy too now that I think about it.
 
3:37 AM
[rubberduck-vba/Rubberduck] build for commit 90c5c51a on unknown branch: 57.82% (target 0%)
 
For your purpose, you should really only care about line continuations.
 
yeah
but I just realized I can't assume the selection is on the first line of the logical line
I can do this
 
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4389?src=pr&el=h1) Report
> Merging [#4389](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4389?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/6df939d9edd3dd3f129f74996e6936f3c880e6da?src=pr&el=desc) will **increase** coverage by `0.06%`.
> The diff coverage is `57.14%`.


```diff
@@ Coverage Diff @@
## next #4389 +/- ##
=======================
 
4:04 AM
gosh this is getting ugly
            var lines = new List<string>();
            var currentLineIndex = pSelection.StartLine;
            var currentLine = module.GetLines(currentLineIndex, 1);

            while (currentLineIndex >= 1)
            {
                lines.Insert(0, currentLine);
                currentLineIndex--;
                if (currentLineIndex >= 1)
                {
                    currentLine = module.GetLines(currentLineIndex, 1);
                    if (!currentLine.Replace("\r\n", string.Empty).EndsWith(" _"))
and that's just the walk up
I have a bad feeling about the performance of this
 
Would it be better to pull the entire procedure at once?
 
what if current selection is in the declarations section?
 
Pull the whole declarations section then.
 
The performance hit is going to be in the COM calls.
 
4:08 AM
yeah
I'm thinking of pulling [up to] 20 lines above and [up to] 20 lines below current position
can't have more than 20 line continuations anyway, right?
actually, pulling 1 line above and 1 line below should cover 95% of line-continuation cases
 
Ironically the auto line continuation feature expands the 5% quickly.
 
The main problem is that you can't tell if you're on a continued line. Detecting that your line is continued is trivial.
 
yeah, need to walk up one line every time at least once
1. Make it work
2. Make it right
3. Make it fast
 
Although, there are a bunch of cases where a line continuation is heuristically impossible.
 
4:15 AM
I'm still at 1
yeah
I'll start with getting the logical code line, then refactor
the eventargs is doing redundant COM hits
 
Or irrelevant I guess.
 _
    If bar Then baz
 
yeah.. doesn't matter - I need SCPs to work off logical code lines
 
Sub foo _
( _
) _

 _

End Sub
 
yup, even that
#thundercode
 
^
I'm not sure that deserves RD's mercy.
Ummm...
var lenFunction = BuiltInDeclarations.SingleOrDefault(s => s.DeclarationType == DeclarationType.Function && s.Scope.Equals("VBE7.DLL;VBA.Strings.Len"));
var lenbFunction = BuiltInDeclarations.SingleOrDefault(s => s.DeclarationType == DeclarationType.Function && s.Scope.Equals("VBE7.DLL;VBA.Strings.Len"));
 
4:21 AM
that's screwing VB6 isn't it?
 
I think there might be a "B" missing on the second one...
 
or is it test-setup code?
oh wow
 
That's in UnassignedVariableUsageInspection
 
screwing VB6 and VBA6 then
Scope string shouldn't be used for this...
 
Not entirely sure why that's special cased.
 
4:23 AM
it's an old inspection, ...probably a work-around for a COM/resolver problem that was since fixed
 
Could be. The comment is //The parameter scoping was apparently incorrect before - need to filter for the actual function.
 
> It was version 1.43 - which was the reason I switched to 2.0.8.
nope, not old at all
 
Still valid though.
If it's passed as a parameter to those functions it doesn't need to be initialized.
 
4:35 AM
oooh
 
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4389?src=pr&el=h1) Report
> Merging [#4389](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4389?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/6df939d9edd3dd3f129f74996e6936f3c880e6da?src=pr&el=desc) will **increase** coverage by `0.06%`.
> The diff coverage is `57.14%`.


```diff
@@ Coverage Diff @@
## next #4389 +/- ##
=======================
 
@Comintern I think there's already an issue (or maybe a couple of issues) for escaping pasted text, not only for double quotes, but also for strings longer than 1024 characters, and for multi-line pastes
 
@ThunderFrame Non-unique idea then. :-D
 
I hate having to paste multiline SQL and then revisit every line to escape everything and concatenate everything properly....
 
4:40 AM
#progress
 
result should be named evil.
 
great. prettifier doesn't handle it
 
Woah. When did I get a dup hammer?
 
[rubberduck-vba/Rubberduck] build for commit 3a5e485c on unknown branch: AppVeyor build succeeded
 
> Awarded yesterday to

Comintern
16.2k42050
 
4:44 AM
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4389?src=pr&el=h1) Report
> Merging [#4389](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4389?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/6df939d9edd3dd3f129f74996e6936f3c880e6da?src=pr&el=desc) will **increase** coverage by `0.07%`.
> The diff coverage is `76.92%`.


```diff
@@ Coverage Diff @@
## next #4389 +/- ##
=======================
 
@Comintern congrats!
 
[rubberduck-vba/Rubberduck] build for commit 3a5e485c on unknown branch: 57.83% (target 0%)
 
Thanks. Was apparently earlier today.
 
crap. the prettifier is totally written for single-line inputs
 
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=h1) Report
> Merging [#4387](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/49d5bfb9e9d3e92e4a80acdb2af68123827bbf02?src=pr&el=desc) will **increase** coverage by `0.08%`.
> The diff coverage is `40.88%`.


```diff
@@ Coverage Diff @@
## next #4387 +/- ##
=======================
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4389?src=pr&el=h1) Report
> Merging [#4389](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4389?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/6df939d9edd3dd3f129f74996e6936f3c880e6da?src=pr&el=desc) will **increase** coverage by `0.07%`.
> The diff coverage is `76.92%`.


```diff
@@ Coverage Diff @@
## next #4389 +/- ##
=======================
> Current status: SCP/AC handler now correctly identifies the logical line of code for the current caret position. Once CodeStringPrettifier handles multiline inputs, SCP will handle matching parenthesis deletion. Currently... multiline inputs get wrecked by the prettifier.
 
4:49 AM
TTGTB
 
'night.
 
[rubberduck-vba/Rubberduck] build for commit a680245d on unknown branch: AppVeyor build succeeded
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=h1) Report
> Merging [#4387](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/49d5bfb9e9d3e92e4a80acdb2af68123827bbf02?src=pr&el=desc) will **increase** coverage by `0.04%`.
> The diff coverage is `35.44%`.


```diff
@@ Coverage Diff @@
## next #4387 +/- ##
=======================
[rubberduck-vba/Rubberduck] build for commit a680245d on unknown branch: 57.81% (target 0%)
> # [Codecov](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=h1) Report
> Merging [#4387](https://codecov.io/gh/rubberduck-vba/Rubberduck/pull/4387?src=pr&el=desc) into [next](https://codecov.io/gh/rubberduck-vba/Rubberduck/commit/49d5bfb9e9d3e92e4a80acdb2af68123827bbf02?src=pr&el=desc) will **increase** coverage by `0.04%`.
> The diff coverage is `35.44%`.


```diff
@@ Coverage Diff @@
## next #4387 +/- ##
=======================
> I can't replicate this in the current build (and I don't think that anything relevant was changed). Are you sure it's Rename -> Refactor?
 
5:20 AM
> This isn't a duplicate Project ID - [the failing line of code is here](https://github.com/rubberduck-vba/Rubberduck/blob/next/Rubberduck.Parsing/VBA/ComReferenceLoading/COMReferenceSynchronizerBase.cs#L149). That raises the question, can an unsaved workbook be used as a reference?

If not, I'm not entirely sure whether we need to add them at that point.
 
5:51 AM
Night pond.
 
6:43 AM
> > can an unsaved workbook be used as a reference?

I don't think it's possible. (Assuming you're only talking VBA here.) The `References` object has the methods `AddFromFile` and `AddFromGuid` - and both, I assume need an existing file in the end.
When trying to add a reference to a new workbook (with a renamed project VBAProjectNew) manually via the GUI,

1. it shows `UNSAVED: VBAProjectNew` in the reference list and
2. on trying to select that reference, a popup will tell you that you'
> > can an unsaved workbook be used as a reference?

I don't think it's possible. (Assuming you're only talking VBA here.) The `References` object has the methods `AddFromFile` and `AddFromGuid` - and both, I assume, need an existing file in the end.

When trying to add a reference to a new workbook (with a renamed project VBAProjectNew) manually via the GUI,

1. it shows `UNSAVED: VBAProjectNew` in the reference list and
2. on trying to select that reference, a popup will tell you that y
 
 
5 hours later…
11:52 AM
[rubberduck-vba/Rubberduck] comintern pushed commit 19ebfb92 to next: Rewire autocomplete settings. Closes #4339
[rubberduck-vba/Rubberduck] comintern pushed commit 90c5c51a to next: Allow ImplicitDefaultMemberAssignmentInspection to be ignored. Closes #4327
[rubberduck-vba/Rubberduck] comintern pushed commit 3a5e485c to next: Test for ignored inspection based on where the QF puts the annotation. Closes #4364
Merge pull request #4389 from comintern/bugfixes

Various bug fixes.
> Yes, @comintern, I'm 100% certain, but I just discovered a simple MCVE won't cover it.

I opened an Excel project and it showed me a very small basic module - 1 method, about a dozen lines of code. I could _not_ reproduce it. I was just about to close this out when a thought hit.

I opened a much larger basic module - 8 methods, about 400 LOC. In _this_ module, I can reproduce it at will. Here's a screen shot showing where the last line in the module was after each rename - I added a comm
 
Hey, @ThunderFrame, welcome back! Glad to see you survived and that the move went well.
 
@Duga installed
 
12:51 PM
Work in progress: self-closing pair completion feature feels 💯 rock-solid at this point - once finished, will handle ✨matching parenthesis deletion✨ ...across line-continuated statements! 😍 #OSS #VBA #AutoComplete #ComingSoon https://github.com/rubberduck-vba/Rubberduck/pull/4387
2
As Stack Overflow nears nears the 10 year threshold, I would just like to thank the community for all their hard work and say: Stack Overflow has a space in it. And no, it's not a tab you heathens.
 
It's additionally confusing that you pass var2 to your R script as the first parameter then var1 as the script's second parameter. You may want to consider renaming those variables which reflect the data they're holding (perhaps scriptPath and argument) or at least put them in the numerical order they'll be used. Future programmers who have to maintain this code (including future you) will thank you. — FreeMan 1 min ago
 
> Wow, just installed the latest release and this new 'remove' setting is awesome. So much easier to clean up code with predictable cursor movement. Thank you for implementing this!!
 
1:35 PM
@TweetingDuck What the heck, did you take a lesson in tweeting from the esteemed Trump?
That is one unintelligible tweet. Perhaps because I don't speak emoji.
 
@Hosch250 nah that would have been "RUBBERDUCK WILL HAVE THE MOSTEST GREATEST BESTEST SELF-CLOSING PAIR COMPLETION EVER SEEN. NOTHING LIKE IT HAS EVER BEEN DONE BEFORE, YOU WON'T BELIEVE IT."
2
with a few typos
@FreeMan s/numerical/ordinal, no?
 
1:53 PM
> This is currently implemented in [ShowIntelliSenseCommand.cs](https://github.com/rubberduck-vba/Rubberduck/blob/next/Rubberduck.Core/AutoComplete/ShowIntelliSenseCommand.cs) which invokes command ID 2531 (probably needs adjustment for VB6 support, cc @mansellan), however I ended up commenting it out because whenever that command is invoked and there's no "quick info" available, the VBE makes a very annoying "ding!" (beep?).

Ideas welcome - closing/declining this issue for now.
> This is currently implemented in [ShowIntelliSenseCommand.cs](https://github.com/rubberduck-vba/Rubberduck/blob/next/Rubberduck.Core/AutoComplete/ShowIntelliSenseCommand.cs) which invokes command ID 2531 (probably needs adjustment for VB6 support, cc @mansellan), however I ended up commenting it out because whenever that command is invoked and there's no "quick info" available, the VBE makes a very annoying "ding!" (beep?).

Ideas welcome - closing/declining this enhancement for now.
> This scenario just needs a unit test, I believe it's currently fixed in #4387
 
@MathieuGuindon What'll you give if I can get him to tweet about it?
 
400 million profile views, I guess
 
That's what you'll get.
 
00:00 - 14:0014:00 - 23:00

« first day (1574 days earlier)      last day (1606 days later) »