code: function (dereference) {
          if (dereference.object.type !== 'Identifier') return
          if (!namespaces.has(dereference.object.name)) return
  
          if (dereference.parent.type === 'AssignmentExpression' &&
              dereference.parent.left === dereference) {
              context.report(dereference.parent,
                  `Assignment to member of namespace '${dereference.object.name}'.`)
          }
  
          // go deep
          var namespace = namespaces.get(dereference.object.name)
          var namepath = [dereference.object.name]
          // while property is namespace and parent is member expression, keep validating
          while (namespace instanceof Exports &&
                 dereference.type === 'MemberExpression') {
  
            if (dereference.computed) {
              if (!allowComputed) {
                context.report(dereference.property,
                  'Unable to validate computed reference to imported namespace \'' +
                  dereference.object.name + '\'.')
              }
              return
            }
  
            if (!namespace.has(dereference.property.name)) {
              context.report(
                dereference.property,
                makeMessage(dereference.property, namepath))
              break
            }
  
            const exported = namespace.get(dereference.property.name)
            if (exported == null) return
  
            // stash and pop
            namepath.push(dereference.property.name)
            namespace = exported.namespace
            dereference = dereference.parent
          }
  
        }
docs: todo: check for possible redefinition