Пример #1
0
 /**
  * @param path path to first element
  * @param pathTo path to second element
  * @return environment in which the generic parameters in the path to the first element are bound
  *     to those in the path to the second element, or null type on error
  */
 public static ResolvedName mapGenericParameters(
     final Deque<? extends INamedElement> path, final Deque<? extends INamedElement> pathTo) {
   // Construct an environment in which the current function's generic parameters
   // are bound to those of the eventual override.
   final Deque<List<? extends ResolvedName>> tableau =
       new LinkedList<>(ResolvedName.fromNamedElement(path.getLast()).tableau());
   final Iterator<? extends INamedElement> pathIt = path.descendingIterator();
   while (pathIt.hasNext()) {
     pathIt.next();
     tableau.removeLast();
   }
   CachedIterator<? extends INamedElement> itPathTo = null;
   CachedIterator<? extends IGenericParameter> itGPTo = null;
   boolean end = false;
   {
     // Initialise iterators into direct override's generic parameters.
     boolean foundValid = false;
     itPathTo = Iterators.cached(pathTo.iterator());
     while (!foundValid && itPathTo.hasItem()) {
       itGPTo = Iterators.cached(itPathTo.item().genericParameters().iterator());
       while (!foundValid && itGPTo.hasItem()) {
         foundValid = true;
         if (!foundValid) itGPTo.next();
       }
       if (!foundValid) itPathTo.next();
     }
     if (!foundValid) end = true;
   }
   for (final INamedElement elt : path) {
     final List<ResolvedName> row = new ArrayList<>();
     for (@SuppressWarnings("unused")
     final IGenericParameter genericParameter : elt.genericParameters()) {
       if (end) return null;
       row.add(ResolvedName.fromNamedElement(itGPTo.item()));
       {
         // Increment iterators into direct override's generic parameters.
         boolean init = true;
         boolean foundValid = false;
         if (!init) itPathTo = Iterators.cached(pathTo.iterator());
         while (!foundValid && itPathTo.hasItem()) {
           if (!init) itGPTo = Iterators.cached(itPathTo.item().genericParameters().iterator());
           while (!foundValid && itGPTo.hasItem()) {
             if (!init) foundValid = true;
             init = false;
             if (!foundValid) itGPTo.next();
           }
           if (!foundValid) itPathTo.next();
         }
         if (!foundValid) end = true;
       }
     }
     tableau.add(row);
   }
   if (!end) return null;
   return ResolvedName.newNameReference(path.getLast(), tableau);
 }
Пример #2
0
 /**
  * @param namedElement named element
  * @return ancestors of the named element, beginning with the root namespace and ending with the
  *     named element itself, skipping local scopes
  */
 public static Iterable<? extends INamedElement> ancestors(final INamedElement namedElement) {
   final Deque<INamedElement> ancestors = new LinkedList<>();
   INamedElement ancestor = namedElement;
   while (membership(ancestor) != ScopeMembership.Root) {
     ancestors.addFirst(ancestor);
     ancestor = parentNamedElementOfScope(ancestor.parent());
   }
   ancestors.addFirst(ancestor);
   return ancestors;
 }
Пример #3
0
  /**
   * @param instanceFrame instance frame
   * @return iterable over instance members of the frame, including those nested in namespaces
   */
  public static Iterable<? extends INamedElement> instanceMembers(
      final IInstanceFrame instanceFrame) {
    final List<INamedElement> members = new ArrayList<>();

    // Iterate over the member functions of the frame, including those nested in namespaces.
    final Deque<INamedElement> queue = new LinkedList<>();
    queue.addLast(instanceFrame);
    while (!queue.isEmpty()) {
      final INamedElement cur = queue.getFirst();
      queue.removeFirst();

      final INamedElementContainer contCur = (INamedElementContainer) cur;
      for (final INamedElement member : contCur.members())
        if (Ast.membership(member)
            == (contCur == instanceFrame
                ? ScopeMembership.InstanceMember
                : ScopeMembership.StaticMember)) {
          members.add(member);
          if (member instanceof INamedElementContainer) {
            // Tail-recursively treat this nested namespace.
            queue.addLast(member);
          }
        }
    }

    return members;
  }
Пример #4
0
 /**
  * @param fn function
  * @return eventual overrides of the function, unifying those differing only in generic derivation
  */
 public static Iterable<? extends IFunction> eventualOverrides(final IFunction fn) {
   // Iterate over the eventually overridden functions,
   // unifying those differing only through generic derivation.
   final Set<IFunction> processedEO = new LinkedHashSet<>();
   final Deque<IFunction> queueEO = new LinkedList<>();
   queueEO.addLast(fn);
   while (!queueEO.isEmpty()) {
     final IFunction fnEO = queueEO.getFirst();
     queueEO.removeFirst();
     if (!processedEO.contains(fnEO)) {
       processedEO.add(fnEO);
       // Tail-recurse on the function's direct overrides.
       for (final ResolvedName directOverride : fnEO.directOverrides())
         queueEO.addLast((IFunction) directOverride.namedElement());
     }
   }
   return processedEO;
 }