home *** CD-ROM | disk | FTP | other *** search
/ Symantec Visual Cafe for Java 2.5 / symantec-visual-cafe-2.5-database-dev-edition.iso / VPage / Java.bin / CLASSES.ZIP / sun / tools / java / ClassDefinition.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-07-08  |  16.6 KB  |  834 lines
  1. package sun.tools.java;
  2.  
  3. import java.io.PrintStream;
  4. import java.util.Enumeration;
  5. import java.util.Hashtable;
  6. import java.util.Vector;
  7. import sun.tools.tree.Context;
  8. import sun.tools.tree.Expression;
  9. import sun.tools.tree.LocalField;
  10. import sun.tools.tree.UplevelReference;
  11. import sun.tools.tree.Vset;
  12.  
  13. public class ClassDefinition implements Constants {
  14.    protected Object source;
  15.    protected int where;
  16.    protected int modifiers;
  17.    protected Identifier localName;
  18.    protected ClassDeclaration declaration;
  19.    protected IdentifierToken superClassId;
  20.    protected IdentifierToken[] interfaceIds;
  21.    protected ClassDeclaration superClass;
  22.    protected ClassDeclaration[] interfaces;
  23.    protected ClassDefinition outerClass;
  24.    protected FieldDefinition outerField;
  25.    protected FieldDefinition innerClassField;
  26.    protected FieldDefinition firstField;
  27.    protected FieldDefinition lastField;
  28.    protected boolean resolved;
  29.    protected String documentation;
  30.    protected boolean error;
  31.    protected UplevelReference references;
  32.    protected boolean referencesFrozen;
  33.    private Hashtable fieldHash = new Hashtable(31);
  34.    private int abstr;
  35.  
  36.    protected ClassDefinition(Object var1, int var2, ClassDeclaration var3, int var4, IdentifierToken var5, IdentifierToken[] var6) {
  37.       this.source = var1;
  38.       this.where = var2;
  39.       this.declaration = var3;
  40.       this.modifiers = var4;
  41.       this.superClassId = var5;
  42.       this.interfaceIds = var6;
  43.    }
  44.  
  45.    public final Object getSource() {
  46.       return this.source;
  47.    }
  48.  
  49.    public final boolean getError() {
  50.       return this.error;
  51.    }
  52.  
  53.    public final void setError(boolean var1) {
  54.       this.error = var1;
  55.    }
  56.  
  57.    public final int getWhere() {
  58.       return this.where;
  59.    }
  60.  
  61.    public final ClassDeclaration getClassDeclaration() {
  62.       return this.declaration;
  63.    }
  64.  
  65.    public final int getModifiers() {
  66.       return this.modifiers;
  67.    }
  68.  
  69.    public final ClassDeclaration getSuperClass() {
  70.       return this.superClass;
  71.    }
  72.  
  73.    public ClassDeclaration getSuperClass(Environment var1) {
  74.       if (this.superClass == null && this.superClassId != null) {
  75.          this.resolveTypeStructure(var1);
  76.          if (this.superClass == null && this.superClassId != null) {
  77.             var1.error(this.where, "cyclic.scoping");
  78.          }
  79.       }
  80.  
  81.       return this.superClass;
  82.    }
  83.  
  84.    public final ClassDeclaration[] getInterfaces() {
  85.       if (this.interfaces == null) {
  86.          throw new CompilerError("getInterfaces");
  87.       } else {
  88.          return this.interfaces;
  89.       }
  90.    }
  91.  
  92.    public final ClassDefinition getOuterClass() {
  93.       return this.outerClass;
  94.    }
  95.  
  96.    protected final void setOuterClass(ClassDefinition var1) {
  97.       if (this.outerClass != null) {
  98.          throw new CompilerError("setOuterClass");
  99.       } else {
  100.          this.outerClass = var1;
  101.       }
  102.    }
  103.  
  104.    protected final void setOuterField(FieldDefinition var1) {
  105.       if (!this.isStatic() && this.isInnerClass()) {
  106.          if (this.outerField != null) {
  107.             throw new CompilerError("setOuterField");
  108.          } else {
  109.             this.outerField = var1;
  110.          }
  111.       } else {
  112.          throw new CompilerError("setOuterField");
  113.       }
  114.    }
  115.  
  116.    public final boolean isInnerClass() {
  117.       return this.outerClass != null;
  118.    }
  119.  
  120.    public final boolean isMember() {
  121.       return this.outerClass != null && !this.isLocal();
  122.    }
  123.  
  124.    public final boolean isTopLevel() {
  125.       return this.outerClass == null || this.isStatic() || this.isInterface();
  126.    }
  127.  
  128.    public final boolean isInsideLocal() {
  129.       return this.isLocal() || this.outerClass != null && this.outerClass.isInsideLocal();
  130.    }
  131.  
  132.    public Identifier getLocalName() {
  133.       return this.localName != null ? this.localName : this.getName().getFlatName().getName();
  134.    }
  135.  
  136.    public void setLocalName(Identifier var1) {
  137.       if (this.isLocal()) {
  138.          this.localName = var1;
  139.       }
  140.  
  141.    }
  142.  
  143.    public final FieldDefinition getInnerClassField() {
  144.       if (this.outerClass == null) {
  145.          return null;
  146.       } else {
  147.          if (this.innerClassField == null) {
  148.             Identifier var1 = this.getName().getFlatName().getName();
  149.  
  150.             for(FieldDefinition var2 = this.outerClass.getFirstMatch(var1); var2 != null; var2 = var2.getNextMatch()) {
  151.                if (var2.isInnerClass()) {
  152.                   this.innerClassField = var2;
  153.                   break;
  154.                }
  155.             }
  156.  
  157.             if (this.innerClassField == null) {
  158.                throw new CompilerError("getInnerClassField");
  159.             }
  160.          }
  161.  
  162.          return this.innerClassField;
  163.       }
  164.    }
  165.  
  166.    public final FieldDefinition findOuterField() {
  167.       return this.outerField;
  168.    }
  169.  
  170.    public final boolean isStatic() {
  171.       return (this.modifiers & 8) != 0;
  172.    }
  173.  
  174.    public final ClassDefinition getTopClass() {
  175.       ClassDefinition var1;
  176.       ClassDefinition var2;
  177.       for(var1 = this; (var2 = var1.outerClass) != null; var1 = var2) {
  178.       }
  179.  
  180.       return var1;
  181.    }
  182.  
  183.    public final FieldDefinition getFirstField() {
  184.       return this.firstField;
  185.    }
  186.  
  187.    public final FieldDefinition getFirstMatch(Identifier var1) {
  188.       return (FieldDefinition)this.fieldHash.get(var1);
  189.    }
  190.  
  191.    public final Identifier getName() {
  192.       return this.declaration.getName();
  193.    }
  194.  
  195.    public final Type getType() {
  196.       return this.declaration.getType();
  197.    }
  198.  
  199.    public String getDocumentation() {
  200.       return this.documentation;
  201.    }
  202.  
  203.    public static boolean containsDeprecated(String var0) {
  204.       if (var0 == null) {
  205.          return false;
  206.       } else {
  207.          int var5;
  208.          for(var5 = 0; (var5 = var0.indexOf("@deprecated", var5)) >= 0; var5 += "@deprecated".length()) {
  209.             int var2 = var5 - 1;
  210.  
  211.             while(true) {
  212.                if (var2 >= 0) {
  213.                   char var3 = var0.charAt(var2);
  214.                   if (var3 != '\n' && var3 != '\r') {
  215.                      if (!Character.isSpace(var3)) {
  216.                         break;
  217.                      }
  218.  
  219.                      --var2;
  220.                      continue;
  221.                   }
  222.                }
  223.  
  224.                int var6 = var5 + "@deprecated".length();
  225.                if (var6 >= var0.length()) {
  226.                   return true;
  227.                }
  228.  
  229.                char var4 = var0.charAt(var6);
  230.                if (var4 == '\n' || var4 == '\r' || Character.isSpace(var4)) {
  231.                   return true;
  232.                }
  233.                break;
  234.             }
  235.          }
  236.  
  237.          return false;
  238.       }
  239.    }
  240.  
  241.    public final boolean isInterface() {
  242.       return (this.getModifiers() & 512) != 0;
  243.    }
  244.  
  245.    public final boolean isClass() {
  246.       return (this.getModifiers() & 512) == 0;
  247.    }
  248.  
  249.    public final boolean isPublic() {
  250.       return (this.getModifiers() & 1) != 0;
  251.    }
  252.  
  253.    public final boolean isPrivate() {
  254.       return (this.getModifiers() & 2) != 0;
  255.    }
  256.  
  257.    public final boolean isProtected() {
  258.       return (this.getModifiers() & 4) != 0;
  259.    }
  260.  
  261.    public final boolean isFinal() {
  262.       return (this.getModifiers() & 16) != 0;
  263.    }
  264.  
  265.    public final boolean isAbstract() {
  266.       return (this.getModifiers() & 1024) != 0;
  267.    }
  268.  
  269.    public final boolean isAbstract(Environment var1) throws ClassNotFound {
  270.       if (this.isAbstract()) {
  271.          return true;
  272.       } else {
  273.          if (this.abstr == 0) {
  274.             this.abstr = !this.isInterface() && !this.hasAbstractFields(var1) ? -1 : 1;
  275.          }
  276.  
  277.          return this.abstr == 1;
  278.       }
  279.    }
  280.  
  281.    public final boolean isSynthetic() {
  282.       return (this.getModifiers() & 524288) != 0;
  283.    }
  284.  
  285.    public final boolean isDeprecated() {
  286.       return (this.getModifiers() & 262144) != 0;
  287.    }
  288.  
  289.    public final boolean isAnonymous() {
  290.       return (this.getModifiers() & 65536) != 0;
  291.    }
  292.  
  293.    public final boolean isLocal() {
  294.       return (this.getModifiers() & 131072) != 0;
  295.    }
  296.  
  297.    public final boolean hasConstructor() {
  298.       return this.getFirstMatch(Constants.idInit) != null;
  299.    }
  300.  
  301.    public Enumeration getAbstractFields(Environment var1) throws ClassNotFound {
  302.       Vector var2 = new Vector();
  303.       this.getAbstractFields(var1, this, var2);
  304.       return var2.elements();
  305.    }
  306.  
  307.    private void getAbstractFields(Environment var1, ClassDefinition var2, Vector var3) throws ClassNotFound {
  308.       for(FieldDefinition var4 = var2.getFirstField(); var4 != null; var4 = var4.getNextField()) {
  309.          if (var4.isAbstract()) {
  310.             FieldDefinition var5 = this.findMethod(var1, var4.getName(), var4.getType());
  311.             if (var5 == null) {
  312.                var5 = var4;
  313.             }
  314.  
  315.             if (var5.isAbstract() && !var3.contains(var5)) {
  316.                var3.addElement(var5);
  317.             }
  318.          }
  319.       }
  320.  
  321.       ClassDeclaration var7 = var2.getSuperClass();
  322.       if (var7 != null) {
  323.          ClassDefinition var6 = var7.getClassDefinition(var1);
  324.          if (var6.isAbstract(var1)) {
  325.             this.getAbstractFields(var1, var6, var3);
  326.          }
  327.       }
  328.  
  329.    }
  330.  
  331.    public boolean hasAbstractFields(Environment var1) throws ClassNotFound {
  332.       return this.hasAbstractFields(var1, this);
  333.    }
  334.  
  335.    private boolean hasAbstractFields(Environment var1, ClassDefinition var2) throws ClassNotFound {
  336.       for(FieldDefinition var3 = var2.getFirstField(); var3 != null; var3 = var3.getNextField()) {
  337.          if (var3.isAbstract() && var3.isMethod()) {
  338.             FieldDefinition var4 = this.findMethod(var1, var3.getName(), var3.getType());
  339.             if (var4 == null || var4.isAbstract()) {
  340.                return true;
  341.             }
  342.          }
  343.       }
  344.  
  345.       ClassDeclaration var6 = var2.getSuperClass();
  346.       if (var6 != null) {
  347.          ClassDefinition var5 = var6.getClassDefinition(var1);
  348.          if (var5.isAbstract(var1) && this.hasAbstractFields(var1, var5)) {
  349.             return true;
  350.          } else {
  351.             return false;
  352.          }
  353.       } else {
  354.          return false;
  355.       }
  356.    }
  357.  
  358.    public boolean superClassOf(Environment var1, ClassDeclaration var2) throws ClassNotFound {
  359.       while(var2 != null) {
  360.          if (this.getClassDeclaration().equals(var2)) {
  361.             return true;
  362.          }
  363.  
  364.          var2 = var2.getClassDefinition(var1).getSuperClass();
  365.       }
  366.  
  367.       return false;
  368.    }
  369.  
  370.    public boolean enclosingClassOf(ClassDefinition var1) {
  371.       while((var1 = var1.getOuterClass()) != null) {
  372.          if (this == var1) {
  373.             return true;
  374.          }
  375.       }
  376.  
  377.       return false;
  378.    }
  379.  
  380.    public boolean subClassOf(Environment var1, ClassDeclaration var2) throws ClassNotFound {
  381.       for(ClassDeclaration var3 = this.getClassDeclaration(); var3 != null; var3 = var3.getClassDefinition(var1).getSuperClass()) {
  382.          if (var3.equals(var2)) {
  383.             return true;
  384.          }
  385.       }
  386.  
  387.       return false;
  388.    }
  389.  
  390.    public boolean implementedBy(Environment var1, ClassDeclaration var2) throws ClassNotFound {
  391.       while(var2 != null) {
  392.          if (this.getClassDeclaration().equals(var2)) {
  393.             return true;
  394.          }
  395.  
  396.          ClassDeclaration[] var3 = var2.getClassDefinition(var1).getInterfaces();
  397.  
  398.          for(int var4 = 0; var4 < var3.length; ++var4) {
  399.             if (this.implementedBy(var1, var3[var4])) {
  400.                return true;
  401.             }
  402.          }
  403.  
  404.          var2 = var2.getClassDefinition(var1).getSuperClass();
  405.       }
  406.  
  407.       return false;
  408.    }
  409.  
  410.    public boolean canAccess(Environment var1, ClassDeclaration var2) throws ClassNotFound {
  411.       ClassDefinition var3 = var2.getClassDefinition(var1);
  412.       if (var3.isLocal()) {
  413.          return true;
  414.       } else if (var3.isInnerClass()) {
  415.          return this.canAccess(var1, var3.getInnerClassField());
  416.       } else {
  417.          return var3.isPublic() ? true : this.getName().getQualifier().equals(var2.getName().getQualifier());
  418.       }
  419.    }
  420.  
  421.    public boolean canAccess(Environment var1, FieldDefinition var2) throws ClassNotFound {
  422.       if (var2.isPublic()) {
  423.          return true;
  424.       } else if (var2.isProtected() && this.subClassOf(var1, var2.getClassDeclaration())) {
  425.          return true;
  426.       } else {
  427.          return var2.isPrivate() ? this.getTopClass().getClassDeclaration().equals(var2.getTopClass().getClassDeclaration()) : this.getName().getQualifier().equals(var2.getClassDeclaration().getName().getQualifier());
  428.       }
  429.    }
  430.  
  431.    public boolean protectedAccess(Environment var1, FieldDefinition var2, Type var3) throws ClassNotFound {
  432.       return var2.isStatic() || var3.isType(9) && var2.getName() == Constants.idClone && var2.getType().getArgumentTypes().length == 0 || var3.isType(10) && var1.getClassDefinition(var3.getClassName()).subClassOf(var1, this.getClassDeclaration()) || this.getName().getQualifier().equals(var2.getClassDeclaration().getName().getQualifier());
  433.    }
  434.  
  435.    public FieldDefinition getAccessField(Environment var1, Context var2, FieldDefinition var3) {
  436.       return null;
  437.    }
  438.  
  439.    public FieldDefinition getVariable(Environment var1, Identifier var2) throws AmbiguousField, ClassNotFound {
  440.       for(FieldDefinition var3 = this.getFirstMatch(var2); var3 != null; var3 = var3.getNextMatch()) {
  441.          if (var3.isVariable()) {
  442.             return var3;
  443.          }
  444.       }
  445.  
  446.       ClassDeclaration var4 = this.getSuperClass();
  447.       FieldDefinition var5 = var4 != null ? var4.getClassDefinition(var1).getVariable(var1, var2) : null;
  448.  
  449.       for(int var6 = 0; var6 < this.interfaces.length; ++var6) {
  450.          FieldDefinition var7 = this.interfaces[var6].getClassDefinition(var1).getVariable(var1, var2);
  451.          if (var7 != null) {
  452.             if (var5 != null && var7 != var5) {
  453.                throw new AmbiguousField(var7, var5);
  454.             }
  455.  
  456.             var5 = var7;
  457.          }
  458.       }
  459.  
  460.       return var5;
  461.    }
  462.  
  463.    public boolean reportDeprecated(Environment var1) {
  464.       return this.isDeprecated() || this.outerClass != null && this.outerClass.reportDeprecated(var1);
  465.    }
  466.  
  467.    public void noteUsedBy(ClassDefinition var1, int var2, Environment var3) {
  468.       if (this.reportDeprecated(var3)) {
  469.          var3.error(var2, "warn.class.is.deprecated", this);
  470.       }
  471.  
  472.    }
  473.  
  474.    public FieldDefinition getInnerClass(Environment var1, Identifier var2) throws ClassNotFound {
  475.       for(FieldDefinition var3 = this.getFirstMatch(var2); var3 != null; var3 = var3.getNextMatch()) {
  476.          if (var3.isInnerClass() && !var3.getInnerClass().isLocal()) {
  477.             return var3;
  478.          }
  479.       }
  480.  
  481.       ClassDeclaration var4 = this.getSuperClass(var1);
  482.       if (var4 != null) {
  483.          return var4.getClassDefinition(var1).getInnerClass(var1, var2);
  484.       } else {
  485.          return null;
  486.       }
  487.    }
  488.  
  489.    private FieldDefinition matchMethod(Environment var1, ClassDefinition var2, Identifier var3, Type[] var4, FieldDefinition var5, boolean var6) throws AmbiguousField, ClassNotFound {
  490.       for(FieldDefinition var7 = this.getFirstMatch(var3); var7 != null; var7 = var7.getNextMatch()) {
  491.          if (var1.isApplicable(var7, var4) && (var2 == null || var2.canAccess(var1, var7))) {
  492.             if (var6) {
  493.                if (var5 == null || var1.isMoreSpecific(var7, var5)) {
  494.                   var5 = var7;
  495.                }
  496.             } else if (var7 != var5 && !var1.isMoreSpecific(var5, var7)) {
  497.                throw new AmbiguousField(var5, var7);
  498.             }
  499.          }
  500.       }
  501.  
  502.       if (var3.equals(Constants.idInit)) {
  503.          return var5;
  504.       } else {
  505.          if (var5 == null || !var6) {
  506.             ClassDeclaration var8 = this.getSuperClass();
  507.             if (var8 != null) {
  508.                ClassDefinition var9 = var8.getClassDefinition(var1);
  509.                var5 = var9.matchMethod(var1, var2, var3, var4, var5, var6);
  510.                if (this.isInterface()) {
  511.                   ClassDeclaration[] var10 = this.getInterfaces();
  512.  
  513.                   for(int var11 = 0; var11 < var10.length; ++var11) {
  514.                      var5 = var10[var11].getClassDefinition(var1).matchMethod(var1, var2, var3, var4, var5, var6);
  515.                   }
  516.                }
  517.             }
  518.          }
  519.  
  520.          return var5;
  521.       }
  522.    }
  523.  
  524.    public FieldDefinition matchMethod(Environment var1, ClassDefinition var2, Identifier var3, Type[] var4) throws AmbiguousField, ClassNotFound {
  525.       FieldDefinition var5 = this.matchMethod(var1, var2, var3, var4, (FieldDefinition)null, true);
  526.       if (var5 != null) {
  527.          this.matchMethod(var1, var2, var3, var4, var5, false);
  528.       }
  529.  
  530.       return var5;
  531.    }
  532.  
  533.    public FieldDefinition matchMethod(Environment var1, ClassDefinition var2, Identifier var3) throws AmbiguousField, ClassNotFound {
  534.       return this.matchMethod(var1, var2, var3, Type.noArgs);
  535.    }
  536.  
  537.    public FieldDefinition findMethod(Environment var1, Identifier var2, Type var3) throws ClassNotFound {
  538.       for(FieldDefinition var4 = this.getFirstMatch(var2); var4 != null; var4 = var4.getNextMatch()) {
  539.          if (var4.getType().equalArguments(var3)) {
  540.             return var4;
  541.          }
  542.       }
  543.  
  544.       if (var2.equals(Constants.idInit)) {
  545.          return null;
  546.       } else {
  547.          ClassDeclaration var5 = this.getSuperClass();
  548.          return var5 == null ? null : var5.getClassDefinition(var1).findMethod(var1, var2, var3);
  549.       }
  550.    }
  551.  
  552.    protected void basicCheck(Environment var1) throws ClassNotFound {
  553.       if (this.outerClass != null) {
  554.          this.outerClass.basicCheck(var1);
  555.       }
  556.  
  557.    }
  558.  
  559.    public void check(Environment var1) throws ClassNotFound {
  560.    }
  561.  
  562.    public Vset checkLocalClass(Environment var1, Context var2, Vset var3, ClassDefinition var4, Expression[] var5, Type[] var6) throws ClassNotFound {
  563.       throw new CompilerError("checkLocalClass");
  564.    }
  565.  
  566.    public void inlineLocalClass(Environment var1) {
  567.    }
  568.  
  569.    public void resolveTypeStructure(Environment var1) {
  570.    }
  571.  
  572.    public Identifier resolveName(Environment var1, Identifier var2) {
  573.       if (var1.innerClasses()) {
  574.          if (var2.isQualified()) {
  575.             Identifier var7 = this.resolveName(var1, var2.getHead());
  576.             if (!var1.classExists(var7)) {
  577.                return var1.resolvePackageQualifiedName(var2);
  578.             }
  579.  
  580.             try {
  581.                return var1.getClassDefinition(var7).resolveInnerClass(var1, var2.getTail());
  582.             } catch (ClassNotFound var5) {
  583.                return Identifier.lookupInner(var7, var2.getTail());
  584.             }
  585.          }
  586.  
  587.          for(ClassDefinition var3 = this; var3 != null; var3 = var3.outerClass) {
  588.             try {
  589.                FieldDefinition var4 = var3.getInnerClass(var1, var2);
  590.                if (var4 != null) {
  591.                   return var4.getInnerClass().getName();
  592.                }
  593.             } catch (ClassNotFound var6) {
  594.             }
  595.          }
  596.       }
  597.  
  598.       return var1.resolveName(var2);
  599.    }
  600.  
  601.    public Identifier resolveInnerClass(Environment var1, Identifier var2) {
  602.       if (var2.isInner()) {
  603.          throw new CompilerError("inner");
  604.       } else if (var2.isQualified()) {
  605.          Identifier var6 = this.resolveInnerClass(var1, var2.getHead());
  606.  
  607.          try {
  608.             return var1.getClassDefinition(var6).resolveInnerClass(var1, var2.getTail());
  609.          } catch (ClassNotFound var4) {
  610.             return Identifier.lookupInner(var6, var2.getTail());
  611.          }
  612.       } else {
  613.          try {
  614.             FieldDefinition var3 = this.getInnerClass(var1, var2);
  615.             if (var3 != null) {
  616.                return var3.getInnerClass().getName();
  617.             }
  618.          } catch (ClassNotFound var5) {
  619.          }
  620.  
  621.          return Identifier.lookupInner(this.getName(), var2);
  622.       }
  623.    }
  624.  
  625.    public boolean innerClassExists(Identifier var1) {
  626.       for(FieldDefinition var2 = this.getFirstMatch(var1.getHead()); var2 != null; var2 = var2.getNextMatch()) {
  627.          if (var2.isInnerClass() && !var2.getInnerClass().isLocal()) {
  628.             if (var1.isQualified() && !var2.getInnerClass().innerClassExists(var1.getTail())) {
  629.                return false;
  630.             }
  631.  
  632.             return true;
  633.          }
  634.       }
  635.  
  636.       return false;
  637.    }
  638.  
  639.    public FieldDefinition findAnyMethod(Environment var1, Identifier var2) throws ClassNotFound {
  640.       for(FieldDefinition var3 = this.getFirstMatch(var2); var3 != null; var3 = var3.getNextMatch()) {
  641.          if (var3.isMethod()) {
  642.             return var3;
  643.          }
  644.       }
  645.  
  646.       ClassDeclaration var4 = this.getSuperClass();
  647.       return var4 == null ? null : var4.getClassDefinition(var1).findAnyMethod(var1, var2);
  648.    }
  649.  
  650.    public int diagnoseMismatch(Environment var1, Identifier var2, Type[] var3, int var4, Type[] var5) throws ClassNotFound {
  651.       int[] var6 = new int[var3.length];
  652.       Type[] var7 = new Type[var3.length];
  653.       if (!this.diagnoseMismatch(var1, var2, var3, var4, var6, var7)) {
  654.          return -2;
  655.       } else {
  656.          for(int var8 = var4; var8 < var3.length; ++var8) {
  657.             if (var6[var8] < 4) {
  658.                var5[0] = var7[var8];
  659.                return var8 << 2 | var6[var8];
  660.             }
  661.          }
  662.  
  663.          return -1;
  664.       }
  665.    }
  666.  
  667.    private boolean diagnoseMismatch(Environment var1, Identifier var2, Type[] var3, int var4, int[] var5, Type[] var6) throws ClassNotFound {
  668.       boolean var7 = false;
  669.  
  670.       for(FieldDefinition var8 = this.getFirstMatch(var2); var8 != null; var8 = var8.getNextMatch()) {
  671.          if (var8.isMethod()) {
  672.             Type[] var9 = var8.getType().getArgumentTypes();
  673.             if (var9.length == var3.length) {
  674.                var7 = true;
  675.  
  676.                for(int var10 = var4; var10 < var3.length; ++var10) {
  677.                   Type var11 = var3[var10];
  678.                   Type var12 = var9[var10];
  679.                   if (var1.implicitCast(var11, var12)) {
  680.                      var5[var10] = 4;
  681.                   } else {
  682.                      if (var5[var10] <= 2 && var1.explicitCast(var11, var12)) {
  683.                         if (var5[var10] < 2) {
  684.                            var6[var10] = null;
  685.                         }
  686.  
  687.                         var5[var10] = 2;
  688.                      } else if (var5[var10] > 0) {
  689.                         continue;
  690.                      }
  691.  
  692.                      if (var6[var10] == null) {
  693.                         var6[var10] = var12;
  694.                      } else if (var6[var10] != var12) {
  695.                         var5[var10] |= 1;
  696.                      }
  697.                   }
  698.                }
  699.             }
  700.          }
  701.       }
  702.  
  703.       if (var2.equals(Constants.idInit)) {
  704.          return var7;
  705.       } else {
  706.          ClassDeclaration var13 = this.getSuperClass();
  707.          if (var13 != null && var13.getClassDefinition(var1).diagnoseMismatch(var1, var2, var3, var4, var5, var6)) {
  708.             var7 = true;
  709.          }
  710.  
  711.          return var7;
  712.       }
  713.    }
  714.  
  715.    public void addField(FieldDefinition var1) {
  716.       if (this.firstField == null) {
  717.          this.firstField = this.lastField = var1;
  718.       } else if (var1.isSynthetic() && var1.isFinal() && var1.isVariable()) {
  719.          var1.nextField = this.firstField;
  720.          this.firstField = var1;
  721.          var1.nextMatch = (FieldDefinition)this.fieldHash.get(var1.name);
  722.       } else {
  723.          this.lastField.nextField = var1;
  724.          this.lastField = var1;
  725.          var1.nextMatch = (FieldDefinition)this.fieldHash.get(var1.name);
  726.       }
  727.  
  728.       this.fieldHash.put(var1.name, var1);
  729.    }
  730.  
  731.    public void addField(Environment var1, FieldDefinition var2) {
  732.       this.addField(var2);
  733.       if (this.resolved) {
  734.          var2.resolveTypeStructure(var1);
  735.       }
  736.  
  737.    }
  738.  
  739.    public UplevelReference getReference(LocalField var1) {
  740.       for(UplevelReference var2 = this.references; var2 != null; var2 = var2.getNext()) {
  741.          if (var2.getTarget() == var1) {
  742.             return var2;
  743.          }
  744.       }
  745.  
  746.       return this.addReference(var1);
  747.    }
  748.  
  749.    protected UplevelReference addReference(LocalField var1) {
  750.       if (((FieldDefinition)var1).getClassDefinition() == this) {
  751.          throw new CompilerError("addReference " + var1);
  752.       } else {
  753.          this.referencesMustNotBeFrozen();
  754.          UplevelReference var2 = new UplevelReference(this, var1);
  755.          this.references = var2.insertInto(this.references);
  756.          return var2;
  757.       }
  758.    }
  759.  
  760.    public UplevelReference getReferences() {
  761.       return this.references;
  762.    }
  763.  
  764.    public UplevelReference getReferencesFrozen() {
  765.       this.referencesFrozen = true;
  766.       return this.references;
  767.    }
  768.  
  769.    public final void referencesMustNotBeFrozen() {
  770.       if (this.referencesFrozen) {
  771.          throw new CompilerError("referencesMustNotBeFrozen " + this);
  772.       }
  773.    }
  774.  
  775.    public void addDependency(ClassDeclaration var1) {
  776.       throw new CompilerError("addDependency");
  777.    }
  778.  
  779.    public void print(PrintStream var1) {
  780.       if (this.isPublic()) {
  781.          var1.print("public ");
  782.       }
  783.  
  784.       if (this.isInterface()) {
  785.          var1.print("interface ");
  786.       } else {
  787.          var1.print("class ");
  788.       }
  789.  
  790.       var1.print(this.getName() + " ");
  791.       if (this.getSuperClass() != null) {
  792.          var1.print("extends " + this.getSuperClass().getName() + " ");
  793.       }
  794.  
  795.       if (this.interfaces.length > 0) {
  796.          var1.print("implements ");
  797.  
  798.          for(int var2 = 0; var2 < this.interfaces.length; ++var2) {
  799.             if (var2 > 0) {
  800.                var1.print(", ");
  801.             }
  802.  
  803.             var1.print(this.interfaces[var2].getName());
  804.             var1.print(" ");
  805.          }
  806.       }
  807.  
  808.       var1.println("{");
  809.  
  810.       for(FieldDefinition var3 = this.getFirstField(); var3 != null; var3 = var3.getNextField()) {
  811.          var1.print("    ");
  812.          var3.print(var1);
  813.       }
  814.  
  815.       var1.println("}");
  816.    }
  817.  
  818.    public String toString() {
  819.       return this.getClassDeclaration().toString();
  820.    }
  821.  
  822.    public void cleanup(Environment var1) {
  823.       if (var1.dump()) {
  824.          var1.output("[cleanup " + this.getName() + "]");
  825.       }
  826.  
  827.       for(FieldDefinition var2 = this.getFirstField(); var2 != null; var2 = var2.getNextField()) {
  828.          var2.cleanup(var1);
  829.       }
  830.  
  831.       this.documentation = null;
  832.    }
  833. }
  834.