object

Bottom type. See spec/type.

All D class objects inherit from Object.

Information about an interface. When an object is accessed via an interface, an Interface* appears as the first entry in its vtbl.

Array of pairs giving the offset and type information for each member in an aggregate.

Runtime type information about a type. Can be retrieved for any type using a expression,TypeidExpression, TypeidExpression.

Runtime type information about a class. Can be retrieved from an object instance by using the

An instance of ModuleInfo is generated into the object file for each compiled module.

It provides access to various aspects of the module. It is not generated for betterC.

The base class of all thrown objects.

All thrown objects must inherit from Throwable. Class Exception, which derives from this class, represents the category of thrown objects that are safe to catch and handle. In principle, one should not catch Throwable objects that are not derived from Exception, as they represent unrecoverable runtime errors. Certain runtime guarantees may fail to hold when these errors are thrown, making it unsafe to continue execution after catching them.

The base class of all errors that are safe to catch and handle.

In principle, only thrown objects derived from this class are safe to catch inside a catch block. Thrown objects not derived from Exception represent runtime errors that should not be caught, as certain runtime guarantees may not hold, making it unsafe to continue program execution.

The base class of all unrecoverable runtime errors.

This represents the category of Throwable objects that are not safe to catch and handle. In principle, one should not catch Error objects, as they represent unrecoverable runtime errors. Certain runtime guarantees may fail to hold when these errors are thrown, making it unsafe to continue execution after catching them.

shortcuts for the precise GC, also generated by the compiler used instead of the actual pointer bitmap

Create RTInfo for type T

Provides an "inline import", i.e. an import that is only available for a limited lookup. For example:

void fun(imported!"std.stdio".File input)
{
   ... use File from std.stdio normally ...
}

There is no need to import std.stdio at top level, so fun carries its own dependencies. The same approach can be used for template constraints:

void fun(T)(imported!"std.stdio".File input, T value)
if (imported!"std.traits".isIntegral!T)
{
   ...
}

An inline import may be used in conjunction with the with statement as well. Inside the scope controlled by with, all symbols in the imported module are made available:

void fun()
{
   with (imported!"std.datetime")
   with (imported!"std.stdio")
   {
       Clock.currTime.writeln;
   }
}

The advantages of inline imports over top-level uses of the import declaration are the following:

• The imported template specifies dependencies at declaration level, not at

  module level. This allows reasoning about the dependency cost of declarations in separation instead of aggregated at module level.

• Declarations using imported are easier to move around because they don't

  require top-level context, making for simpler and quicker refactorings.

• Declarations using imported scale better with templates. This is because

  templates that are not instantiated do not have their parameters and constraints instantiated, so additional modules are not imported without necessity. This makes the cost of unused templates negligible. Dependencies are pulled on a need basis depending on the declarations used by client code.

The use of imported also has drawbacks:

• If most declarations in a module need the same imports, then factoring them

  at top level, outside the declarations, is simpler than repeating them.

• Traditional dependency-tracking tools such as make and other build systems

  assume file-level dependencies and need special tooling (such as rdmd) in order to work efficiently.

• Dependencies at the top of a module are easier to inspect quickly than

  dependencies spread throughout the module.