Display the source code in dmd/escape.d from which this page was generated on github.

If you spot a problem with this page, click here to create a Bugzilla issue.

Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using local clone.

Module `dmd.escape`

Most of the logic to implement scoped pointers and scoped references is here.

Documentation

https://dlang.org/phobos/dmd_escape.html

Coverage

https://codecov.io/gh/dlang/dmd/src/master/src/dmd/escape.d

Functions

Name	Description
`checkArrayLiteralEscape(sc, ae, gag)`	Array literal is going to be allocated on the GC heap. Check its elements to see if any would escape by going on the heap.
`checkAssignEscape(sc, e, gag, byRef)`	Given an `AssignExp`, determine if the lvalue will cause the contents of the rvalue to escape. Print error messages when these are detected. Infer `scope` attribute for the lvalue where possible, in order to eliminate the error.
`checkAssocArrayLiteralEscape(sc, ae, gag)`	Associative array literal is going to be allocated on the GC heap. Check its elements to see if any would escape by going on the heap.
`checkConstructorEscape(sc, ce, gag)`	Check struct constructor of the form `s.this(args)`, by checking each `return` parameter to see if it gets assigned to `s`.
`checkMutableArguments(sc, fd, tf, ethis, arguments, gag)`	Checks memory objects passed to a function. Checks that if a memory object is passed by ref or by pointer, all of the refs or pointers are const, or there is only one mutable ref or pointer to it.
`checkNewEscape(sc, e, gag)`	Detect cases where pointers to the stack can escape the lifetime of the stack frame by being placed into a GC allocated object. Print error messages when these are detected.
`checkParamArgumentEscape(sc, fdc, parId, vPar, parStc, arg, assertmsg, gag)`	Function parameter `par` is being initialized to `arg`, and `par` may escape. Detect if scoped values can escape this way. Print error messages when these are detected.
`checkParamArgumentReturn(sc, firstArg, arg, param, gag)`	Function argument initializes a `return` parameter, and that parameter gets assigned to `firstArg`. Essentially, treat as `firstArg = arg;`
`checkReturnEscape(sc, e, gag)`	Detect cases where pointers to the stack can escape the lifetime of the stack frame by returning `e` by value. Print error messages when these are detected.
`checkReturnEscapeRef(sc, e, gag)`	Detect cases where returning `e` by `ref` can result in a reference to the stack being returned. Print error messages when these are detected.
`checkThrowEscape(sc, e, gag)`	Detect cases where pointers to the stack can escape the lifetime of the stack frame when throwing `e`. Print error messages when these are detected.
`escapeByRef(e, er, live, retRefTransition)`	e is an expression to be returned by 'ref'. Walk e to determine which variables are possibly being returned by ref, such as: ref int function(int i) { return i; } If e is a form of p, determine which variables have content which is being returned as ref, such as: ref int function(int p) { return p; } Multiple variables can be inserted, because of expressions like this: ref int function(bool b, int i, int p) { return b ? i : *p; }
`escapeByValue(e, er, live, retRefTransition)`	e is an expression to be returned by value, and that value contains pointers. Walk e to determine which variables are possibly being returned by value, such as: int* function(int* p) { return p; } If e is a form of &p, determine which variables have content which is being returned as ref, such as: int* function(int i) { return &i; } Multiple variables can be inserted, because of expressions like this: int function(bool b, int i, int* p) { return b ? &i : p; }
`findAllOuterAccessedVariables(fd, vars)`	Find all variables accessed by this delegate that are in functions enclosing it.
`finishScopeParamInference(funcdecl, f)`	After semantic analysis of the function body, try to infer `scope` / `return` on the parameters
`inferScope(va)`	Infer `scope` for a variable
`isReferenceToMutable(t)`	Is type a reference to a mutable value?
`isReferenceToMutable(p, t)`	Is parameter a reference to a mutable value?
`printScopeFailure(printFunc, v, recursionLimit)`	A `scope` variable was assigned to non-scope parameter `v`. If applicable, print why the parameter was not inferred `scope`.
`returnParamDest(tf, tthis)`	Find out if instead of returning a `return` parameter via a return statement, it is returned via assignment to either `this` or the first parameter.

Structs

Name	Description
`EscapeByResults`	Aggregate the data collected by the escapeBy??() functions.

Enums

Name	Description
`ReturnParamDest`	How a `return` parameter escapes its pointer value

Authors

Walter Bright

License

Boost License 1.0