コード例 #1
0
  private static Operation chooseFunctionForInvocation(
      LinkedList<Operation> functions, FileScope scope) {
    Operation candidate = null;
    int candidatePriority = 0;
    int curPriority;
    for (Operation f : functions) {
      curPriority = 0;

      // Scoped private functions override global ones
      if (f.getScope() == scope) {
        curPriority = 2;
        if (f.isOverride()) {
          curPriority = 4;
        }
      } else if (f.getVisibility() != Visibility.PRIVATE) {
        curPriority = 1;
        if (f.isOverride()) {
          curPriority = 3;
        }
      }
      if (curPriority > candidatePriority) {
        candidate = f;
        candidatePriority = curPriority;
      }
    }
    return candidate;
  }
コード例 #2
0
  void addMethod(Operation f) {

    // Enrichment methods may not declared override
    if (f.isOverride())
      throw Problem.ofType(ProblemId.NATIVE_ENRICHMENT_METHOD_DECLARED_OVERRIDE)
          .at(f.getDefinition())
          .raiseUnrecoverable();

    String uid = f.getUid();
    LinkedHashMap<Signature, LinkedList<Operation>> meths = methods.get(uid);
    if (meths == null) {
      meths = new LinkedHashMap<Signature, LinkedList<Operation>>();
      methods.put(uid, meths);
    }
    addMethod(f, meths);
  }
コード例 #3
0
  public Operation resolveInvocation(FileScope scope, SyntaxNode where, String name, Signature s) {
    LinkedHashMap<Signature, LinkedList<Operation>> funcs = methods.get(name);
    if (funcs == null) return null;
    // No signature specified? Only one method with the name allowed
    if (s == null) {
      if (funcs.size() > 1)
        throw Problem.ofType(ProblemId.AMBIGUOUS_METHOD_ACCESS)
            .at(where)
            .details("method", name, assembleFuncList(funcs))
            .raiseUnrecoverable();
      return chooseFunctionForInvocation(funcs.entrySet().iterator().next().getValue(), scope);
    }
    LinkedList<Operation> funcList = funcs.get(s);
    if (funcList == null) {
      // No direct hit :(

      Operation globalCandidate = null;
      Operation candidate = null;
      boolean error = false;
      for (Signature sig : funcs.keySet()) {
        if (s.canImplicitCastTo(sig)) {
          funcList = funcs.get(sig);
          candidate = chooseFunctionForInvocation(funcList, scope);
          if (candidate != null && globalCandidate != null) {
            error = true;
          }
          globalCandidate = candidate;
        }
        if (error)
          throw Problem.ofType(ProblemId.AMBIGUOUS_METHOD_CALL)
              .at(where)
              .details(
                  "method", candidate.getNameAndSignature(), globalCandidate.getNameAndSignature())
              .raiseUnrecoverable();
        globalCandidate = candidate;
      }
      return globalCandidate;
    }

    // Direct signature hit!
    return chooseFunctionForInvocation(funcList, scope);
  }
コード例 #4
0
  public void generateFunctionIndex() {
    for (String s : methods.keySet()) {
      int index = 0;
      LinkedHashMap<Signature, LinkedList<Operation>> funcs = methods.get(s);
      for (Signature sig : funcs.keySet()) {
        LinkedList<Operation> sameFuncs = funcs.get(sig);

        // If we have only one function, we need no function indices.
        // However, we still mus go through the loop to check for dangling forward-declarations.
        if (sameFuncs.size() == 1 && funcs.size() == 1) {
          index = 0;
        }
        for (Operation f : sameFuncs) {
          if (f.hasBody()) {
            f.setIndex(index++);
          }
        }
      }
    }
  }
コード例 #5
0
  private void addMethod(Operation f, LinkedHashMap<Signature, LinkedList<Operation>> meths) {
    LinkedList<Operation> list = meths.get(f.getSignature());

    // No duplicate method? Everything fine!
    if (list == null) {
      list = new LinkedList<Operation>();
      meths.put(f.getSignature(), list);
      list.add(f);
      return;
    }

    // Function is just a forward declaration and there is already such a function? Skip!
    if (f.isForwardDeclaration()) return;

    // Test for duplicate functions
    ListIterator<Operation> iter = list.listIterator();
    while (iter.hasNext()) {
      Operation f2 = iter.next();

      // Forward declaration? Remove!
      if (f2.isForwardDeclaration()) {
        iter.remove();
        continue;
      }

      // Duplicate?
      if (f2.getScope().equals(f.getScope())
          || (f.getVisibility() != Visibility.PRIVATE
              && f2.getVisibility() != Visibility.PRIVATE)) {
        // TODO: This code was copy pasted from function set. Check if it makes sense for
        // enrichments
        throw Problem.ofType(ProblemId.DUPLICATE_METHOD)
            .at(f.getDefinition(), f2.getDefinition())
            .raiseUnrecoverable();
      }
    }
    list.add(f);
  }