not an issue, but better to have additional check here

[pashanhenlei]

in ApplyEditsToSourceText() (BaseSyntaxElements.cs:302), I implemented a check to ensure that two edits do not overlap; otherwise, the resulting code would be invalid. For example, if one edit replaces a function with an empty string, effectively removing it, and another edit attempts to add a variable inside the removed function, the code would break.

(or maybe it's better to directly embed code text inside syntax node?)

[pema99]

Hmm. could you show me the check you added?

[pashanhenlei]

In my implementation, I only checked that 2 consecutive items shouldn’t have overlapping spans, but I think this approach isn’t robust enough.​​​​​​​​​​​​​​​​

[pema99]

You are probably right.. I'll have to think about this for a bit. I haven't touched the HLSLEditor stuff in a while since I didn't end up using it much.

[pashanhenlei]

I use editor heavily. and currently I also enforce a rule that all edit operations should expand the code rather than reduce it to prevent errors. E.g. to remove a function, instead of replacing it with an empty string, I would surround it with “/” “/“ or “#if 0” “#endif”.

[pema99]

I made an attempt at handling this on this branch https://github.com/pema99/UnityShaderParser/compare/edit-conflicts (see Program.cs for an example).

This way you can choose your own handling when there are conflicting edits, either:

• First edit takes precedent, other edits are ignored
• Last edit takes precedent, other edits are ignored
• Ignore all conflicts (current behavior)
• Custom function provided to pick on a conflict-by-conflict basis

What do you think, does this make sense to you? I might remove the option to give a custom function, it's not clear to me whether it is useful or not.

Example output from Program.cs:

Before:
void bar()
{
    if (true)
    {
        int a = 3;
    }
    if (false)
    {
        int a = 3;
    }
}

After (Default/FirstWins):
void bar()
{
    if (true)
    {}
    if (false)
    {}
}

After (FirstWins):
void bar()
{
    if (true)
    {}
    if (false)
    {}
}

After (LastWins):
void bar()
{
    if (true)
    {
        int foo = 3;
    }
    if (false)
    {
        int foo = 3;
    }
}

After (Custom):
void bar()
{
    if (true)
    {}
    if (false)
    {
        int foo = 3;
    }
}

[pashanhenlei]

I need both edit, so that is why I "enforce a rule that all edit operations should expand the code rather than reduce it ".

[pashanhenlei]

or, in other words, it is hard for me to decide which edit operations should take precedence, and there are many many kinds of edits. so my choice is keep all the edits and made them all be valid.

[pema99]

It's not entirely clear to me what you mean by "edit operations should expand the code rather than reduce it"? Do you mean that they should never remove any text - i.e. all have a Span with size 0?

I find this a bit hard to envision. Do you have any example of some shader code where you want to apply 2 overlapping edits (and not just ignore one of them)?

[pashanhenlei]

In my cases, to ensure the editor can safely execute all editing operations, I set a rule prohibiting any modifications that shorten the code text.
e.g. suppose I have a rule to remove all unsupported functions, and another rule to add ".0" after any integer literals. then for this code segment:
float function_to_be_removed(){
return 1;
}

method 1: Edit(funcNode, ""); AddAfter(literalNode,".0"); will produce invalid code.
method 2: AddBefore(funcNode, "/"); AddAfter(funcNode, "/"); AddAfter(literalNode,".0"); will produce valid code(without checking for which operation should take precedence over the other one).