d的dip1000按域对待引用副本2

前文在此,请先阅读.
这里:

ref int* index() return scope {
    return *ptr;
}

编译器这样看:

ref return scope T index();

按ref和return scope附加到this.a是this.因为a是scope,所以a.index()的返回值也是scope(.1).
然后传递该scope返回值给int*参数不是scope的assign(int*).
赋值scope给非域是错误,编译器会正确诊断.

.1就是编译器做错的地方.中域应用至ref 中,而不是返回的int*值.可通过如下示例展示:

ref int f(ref return scope int* x) @safe
{ 
    return *x;
}

注意返回值是如何没有指针的,但是如果中域时未注解它,编译器会触发错误.如果搞成模板,dmd也会按"中域"推导它.
中域的作用是避免按引用返回f(stackPointer),或逃逸&f(stackPointer),但如下有效:

int g() @safe
{
    int x;
    int y = f(&x); // `y`不是 `域`,该是什么?
    return y; //逃逸f的结果.
}

原示例唯一不同的是,指针负载为不同类型(int*而不是int),这不应影响示例,因为它是间接的第二层,它不应受到域或中域的影响.
顺便,我化简原示例为int**,因为你一般要求这样,但看原代码:

void scoot(scope Array!string a) @safe
{
    a[0] = a[1];
}

这显然不违反scope并且同string[]工作,因此也应同库数组类型工作,否则它是dip1000的糟糕设计.

ref X foo(ref return scope P p)
    ReturnRef-Scope

与你写的一致.

(备忘单已过时了.错.还记得表示returnscope更改为总是Return Scope,而ref scope return从不表明Ref-ReturnScope吗?)
为了清楚起见,把x更改为p:

ref int f(ref return scope int* p) @safe
{ 
    return *p;
}

这按ref return scope编译.这保护了p的值.而不是p的地址.因为p值是返回的值,成功编译.
现在分开return scope:

ref int f(ref5 scope return int* p) @safe
  { 
    return *p;
  }

按return ref scope编译.错误:可能未返回"p"域变量.两者都正确,中域,总是按中域解释.

原示例唯一不同的是,指针负载为不同类型(int*而不是int),这不应影响示例,因为它是间接的第二层,它不应受到域或中域的影响.

该差异使一切不同.
问题是代码存储受域保护的int*p值到未受域保护的*ptr负载指针中.dip1000不能完成.必须用@trusted.

该问题不是'Arr.index'函数是ReturnRefScope还是RefReturnScope,一开始就很清楚它是RefReturnScope.

不,它不是.无论是'scope int[]'还是'scope string[]',域只应用至数组的第一个间接寻址,而不是数组元素.如果索引'scope string[]'并得到'scope string',这是漏洞.

当然不是,但问题是,因为它来自解引用指针,在此之后不应再应用'scope',它不应再是域保护的值.这是用'return scope'从函数签名而不是从中式中推导出来的.

dip1000要点在,在@safe代码中可以栈分配数组,如果没有@trusted就不能索引或分配数组元素,那么它就无意义.

顺便,我找到了解决的方法:转换'ref' 中为指针并解引用它来取非域值.

// 用-preview=dip1000编译
@safe:
struct Arr
{
    int** ptr;

    ref int* index() return scope {
        return *ptr;
    }

    void assign(int* p) scope {
        *ptr = p;
    }
}

void main()
{
    scope Arr a;

    a.assign(*&a.index());

    auto tmp = &a.index();
    a.assign(*tmp);
}