     },
     'in-out': {
       'patterns': [
+        { 'include': '#in-out-x' }
+      ]
+    },
+    'in-out-x': {
+      'patterns': [
         {
           'match': 'auto|final|in|out|lazy|ref|scope',
           'name': 'storage.type.modifier.inout.d'

        { 'include': '#type-ctor' }
      ]
    }

    #
    # Expressions
    #
    # We cheat a bit here, since highlighting expressions is overkill, and in
    # any case we want lexical entities like strings and numbers to be
    # clearly visible.  So we group expressions into a meta class for the
    # purposes of other entities.  Expression entities themselves just highlight
    # lexical elements as well as the base expression operators, and a few
    # others.
    #
    'expression': {
      'patterns': [
          { 'include': '#operator' },
          {
            'match': ',',
            'name': 'keyword.operator.comma.d'
          }
          { 'include': '#lexical' },
      ]
    },
    'conditional-expression': {
      'patterns': [
        {
          # ternary
          'match': '\\?|:',
          'name': 'keyword.operator.ternary.d'
        },
        {
          # logical
          'match': '!<>=|!<=|!>=|<>=|!<>|<=|>=|<>|!>|!<|==|!=|&&|\\|\\||<|>',
          'name': 'keyword.operator.logical.d'
        },
        { 'include': '#lexical' }
      ]
    }
    'operator': {
      'patterns': [
        {
          # assign
          'match': '=|\\+=|-=|\\*=|/=|%=|&=|\\|=|\\^=|~=|<<=|>>=|>>>=|^^=',
          'name': 'keyword.operator.assign.d'
        },
        {
          # ternary
          'match': '\\?|:',
          'name': 'keyword.operator.ternary.d'
        },
        {
          # logical
          'match': '!<>=|!<=|!>=|<>=|!<>|<=|>=|<>|!>|!<|==|!=|&&|\\|\\||<|>',
          'name': 'keyword.operator.logical.d'
        },
        {
          # bitwise
          'match': '\\||\\^|&|<<|>>|>>>',
          'name': 'keyword.operator.bitwise.d'
        },
        {
          # arithmetic
          'match': '\\+|-|\\*|/|%',
          'name': 'keyword.operator.arithmetic.d'
        },
        {
          # unary
          'match': '[=~]\s*(&|\\+\\+|\\--|\\*|-|\\+|!)',
          'name': 'keyword.operator.unary.d'
        },
        {
          # misc
          'match': '~|(\\s+!in\\s+)|(\\s+in\\s+)',
          'name': 'keyword.operator.misc.d'
        },
        {
          # primary expressions
          'match': 'this|super|null|true|false|$',
          'name': 'constant.language.primary.d'
        }

      ]
    },
    'assign-operator': {
      'patterns': [
        {
          'match': '=|\\+=|-=|\\*=|/=|%=|&=|\\|=|\\^=|~=|<<=|>>=|>>>=|^^=',
          'name': 'keyword.operator.assign.d'
        },
        { 'include': '#expression' },
      ]
    },
    'ternary-operator': {
      'patterns:': [
        {
          'match': '(\\?|:)',
          'name': 'keyword.operator.ternary.d'
        },
        {
          'include': '#expression',
        }
      ]
    },
    #
    # Template
    #





    #
    # Declarations
    #
    'declaration': {
      'patterns': [
        { 'include': '#alias-declaration' },
        { 'include': '#aggregate-declaration' },
        { 'include': '#enum-declaration' },
        { 'include': '#import-declaration' },
        { 'include': '#decl' }
      ]
    },
    'alias-declaration': {
      'patterns': [
        {
          'match': 'alias',
          'name': 'keyword.alias.d'
        },
        { 'include': '#storage-class' },
        { 'include': '#basic-type' },
        { 'include': '#declarator' },
        { 'include': '#alias-declaration-x' }
      ]
    },
    #
    # Initializers
    #
    'initializer': {
      'patterns': [
        { 'include': '#void-initializer' },
        { 'include': '#non-void-initializer' }
      ]
    },
    'void-initializer': {
      'patterns': [
        'match': 'void',
        'name': 'support.type.void.d'
      ]
    },
    'non-void-initializer': {
      'patterns': [
        { 'include': '#exp-initializer' },
        { 'include': '#array-initializer' },
        { 'include': '#struct-initializer' }
      ]
    },
    'exp-initializer': {
      'patterns': [
        { 'include': '#expression' }
      ]
    },
    'array-initializer': {
      'patterns': [
        'begin': '\\[',
        'beginCaptures': { '0': { 'name': 'support.type.array.initializer.begin.d' } },
        'end': '\\]',
        'endCaptures': {'0': { 'name': 'support.type.array.initializer.end.d' } },
        'patterns': [
          {
            'match': ',',
            'name': 'keyword.operator.comma.d'
          },
          { 'include': '#array-member-initialization' },
        ]
      ]
    },
    'array-member-initializations': {
      'patterns': [
        {
          'match': ',',
          'name': 'keyword.operator.comma.d'
        },
        { 'include': '#array-member-initialization' },
      ]
    },
    'array-member-initialization': {
      'patterns': [
        { 'include': '#non-void-initializer' },
        { 'include': '#expression' },
        {
          'match': ':',
          'name': 'support.type.tag.d'
        }
      ]
    },
    'struct-initializer': {
      'patterns': [
        'begin': '\\{',
        'beginCaptures': { '0': { 'name': 'support.type.struct.initializer.begin.d' } },
        'end': '\\}',
        'endCaptures': { '0': { 'name': 'support.type.struct.initializer.end.d' } },
        'patterns': [
          { 'include': '#struct-member-initializers' }
        ]
      ]
    }
    'struct-member-initializers': {
      'patterns': [
        {
          'match': ',',
          'name': 'keyword.operator.comma.d'
        },
        { 'include': '#struct-member-initializer' },
      ]
    },
    'struct-member-initializer': {
      'patterns': [
        { 'include': '#non-void-initializer' },
        { 'include': '#identifier' },
        {
          'match': ':',
          'name': 'support.type.tag.d'
        },
      ]
    },
    'default-initializer-expression': {

        { 'include': '#special-keyword' }
      ]
    },
    'function-body': {
      'patterns': [

      ]
    },
    'in-statement': {
      'patterns': [

      ]
    },
    'out-statement': {
      'patterns': [

      ]
    },
    'body-statement': {
      'patterns': [

      ]
    },
    'constructor': {
      'patterns': [

      ]
    },
    'constructor-template': {
      'patterns': [

      ]
    },
    'destructor': {
      'patterns': [
        {
          'match': '~this\\s*\\(\\s*\\)',
          'name': '#entity.name.class.destructor.d'
        },
        { 'include': '#member-function-attributes' },
        { 'include': '#function-body' },
      ]
    },
    'postblit': {
      'patterns': [
        {
          'match': 'this\\s*\\(\\s*this\\s*\\)\\s',
          'name': '#entity.name.class.postblit.d'
        },
        { 'include': '#member-function-attributes' },
        { 'include': '#function-body'}
      ]
    },
    'allocator': {
      'patterns': [
        {
          'match': 'new',
          'name': 'keyword.other.new.d'
        },
        { 'include': '#parameters' },
        { 'include': '#function-body' }
      ]
    },
    'deallocator': {
      'patterns': [
        {
          'match': 'delete',
          'name': 'keyword.other.delete.d'
        },
        { 'include': '#parameters' },
        { 'include': '#function-body' }
      ]
    },
    'invariant': {
      'patterns': [
        {
          'match': 'invariant\\s*\\(\\s*\\)',
          'name': 'entity.name.class.invariant.d'
        },
        { 'include': '#block-statement' }
      ]
    },
    'unit-test': {
      'patterns': [
        {
          'match': 'unittest',
          'name': 'entity.name.function.unit-test.d'
        },
        { 'include': '#function-body' }
      ]
    },
    ###########################################################################
    # Aggregate
    ###########################################################################
