code: private boolean propertyMustBeInitializedByFullName(Name name) {
      // If an object or function literal in the global namespace is never
      // aliased, then its properties can only come from one of 2 places:
      // 1) From its prototype chain, or
      // 2) From an assignment to its fully qualified name.
      // If we assume #1 is not the case, then #2 implies that its
      // properties must all be modeled in the GlobalNamespace as well.
      //
      // We assume that for global object literals and types (constructors and
      // interfaces), we can find all the properties inherited from the prototype
      // chain of functions and objects.
      if (name.getParent() == null) {
        return false;
      }
  
      if (isNameUnsafelyAliased(name.getParent())) {
        // e.g. if we have `const ns = {}; escape(ns); alert(ns.a.b);`
        // we don't expect ns.a.b to be defined somewhere because `ns` has escaped
        return false;
      }
  
      if (objectPrototypeProps.contains(name.getBaseName())) {
        // checks for things on Object.prototype, e.g. a call to
        // something.hasOwnProperty('a');
        return false;
      }
  
      if (name.getParent().isObjectLiteral()) {
        // if this is a property on an object literal, always expect an initialization somewhere
        return true;
      }
  
      if (name.getParent().isClass()) {
        // only warn on class properties if there is no superclass, because we don't handle
        // class side inheritance here very well yet.
        return !hasSuperclass(name.getParent());
      }
  
      // warn on remaining names if they are on a constructor and are not a Function.prototype
      // property (e.g. f.call(1);)
      return name.getParent().isFunction()
          && name.getParent().isDeclaredType()
          && !functionPrototypeProps.contains(name.getBaseName());
    }
docs: The input name is a property. Check whether this property
  must be initialized with its full qualified name.