package jetbrains.mps.workbench.findusages;

/*Generated by MPS */

import jetbrains.mps.annotations.GeneratedClass;
import java.util.Map;
import com.intellij.psi.impl.cache.impl.id.IdIndexEntry;
import gnu.trove.THashMap;
import org.jetbrains.mps.openapi.language.SAbstractConcept;
import org.jetbrains.mps.openapi.model.SNodeId;
import jetbrains.mps.stubs.javastub.classpath.ClassifierKind;
import jetbrains.mps.baseLanguage.javastub.asm.ASMClass;
import jetbrains.mps.baseLanguage.javastub.asm.ASMTypeVariable;
import jetbrains.mps.baseLanguage.javastub.asm.ASMFormalTypeParameter;
import jetbrains.mps.baseLanguage.javastub.asm.ASMType;
import jetbrains.mps.baseLanguage.javastub.asm.ASMMethod;
import jetbrains.mps.baseLanguage.javastub.asm.ASMAnnotation;
import jetbrains.mps.baseLanguage.javastub.asm.ASMField;
import java.util.Iterator;
import jetbrains.mps.internal.collections.runtime.ListSequence;
import java.util.List;
import jetbrains.mps.baseLanguage.javastub.asm.ASMClassType;
import jetbrains.mps.internal.collections.runtime.MapSequence;
import jetbrains.mps.baseLanguage.javastub.asm.ASMPrimitiveType;
import jetbrains.mps.baseLanguage.javastub.asm.ASMEnumValue;
import jetbrains.mps.baseLanguage.javastub.asm.ASMArrayType;
import jetbrains.mps.baseLanguage.javastub.asm.ASMVarArgType;
import jetbrains.mps.baseLanguage.javastub.asm.ASMParameterizedType;
import jetbrains.mps.baseLanguage.javastub.asm.ASMExtendsType;
import jetbrains.mps.baseLanguage.javastub.asm.ASMSuperType;
import jetbrains.mps.baseLanguage.javastub.asm.ASMUnboundedType;
import jetbrains.mps.baseLanguage.javastub.ASMNodeId;
import jetbrains.mps.util.NameUtil;
import org.jetbrains.mps.openapi.language.SConcept;
import jetbrains.mps.smodel.adapter.structure.MetaAdapterFactory;

@GeneratedClass(node = "r:9e8a9ffa-c450-4841-b749-c11aa0f49452(jetbrains.mps.workbench.findusages)/3822554386093951004", model = "r:9e8a9ffa-c450-4841-b749-c11aa0f49452(jetbrains.mps.workbench.findusages)")
public class ClassifierCacher {
  private Map<IdIndexEntry, Integer> myResult = new THashMap<IdIndexEntry, Integer>();
  public ClassifierCacher() {
  }
  public Map<IdIndexEntry, Integer> getResult() {
    return myResult;
  }
  private void instance(SAbstractConcept concept) {
    myResult.put(new IdIndexEntry(concept.getQualifiedName(), true), 0);
  }
  private void ref(SNodeId id) {
    if (!(id instanceof jetbrains.mps.smodel.SNodeId.StringBasedId)) {
      return;
    }
    myResult.put(new IdIndexEntry(id.toString(), true), 0);
  }
  private void modelRef(String packageName) {
    myResult.put(new IdIndexEntry(packageName + "@java_stub", true), 0);
  }
  public void updateClassifier(ClassifierKind kind, ASMClass ac) {
    if (kind == ClassifierKind.CLASS) {
      instance(CONCEPTS.ClassConcept$bK);
      updateAnnotations(ac);
      updateTypeVariables(ac);
      updateExtendsAndImplements(ac);
      updateInstanceFields(ac);
      updateStaticFields(ac);
      updateConstructors(ac);
      updateInstanceMethods(ac);
      updateStaticMethods(ac, kind);
    } else if (kind == ClassifierKind.INTERFACE) {
      instance(CONCEPTS.Interface$db);
      updateAnnotations(ac);
      updateTypeVariables(ac);
      updateExtendsForInterface(ac);
      updateStaticFields(ac);
      updateInstanceMethods(ac);
      updateStaticMethods(ac, kind);
    } else if (kind == ClassifierKind.ANNOTATIONS) {
      instance(CONCEPTS.Annotation$he);
      updateAnnotationMethods(ac);
      updateAnnotations(ac);
    } else if (kind == ClassifierKind.ENUM) {
      instance(CONCEPTS.EnumClass$Vk);
      updateAnnotations(ac);
      updateTypeVariables(ac);
      updateExtendsAndImplements(ac);
      updateInstanceFields(ac);
      updateStaticFields(ac);
      updateConstructors(ac);
      updateInstanceMethods(ac);
      updateStaticMethods(ac, kind);
    } else if (kind == ClassifierKind.UNKNOWN) {
      return;
    }
    if (ac.isPublic()) {
      instance(CONCEPTS.PublicVisibility$R0);
    }
  }
  private void updateTypeVariables(ASMClass cls) {
    for (ASMTypeVariable tv : cls.getTypeParameters()) {
      instance(CONCEPTS.TypeVariableDeclaration$4Y);
      if (!(tv instanceof ASMFormalTypeParameter)) {
        continue;
      }
      ASMFormalTypeParameter tp = (ASMFormalTypeParameter) tv;
      if (tp.getClassBound() != null) {
        getTypeByASMType(tp.getClassBound());
      }
      for (ASMType act : tp.getInterfaceBounds()) {
        getTypeByASMType(act);
      }
    }
  }
  private void updateTypeVariables(ASMMethod method) {
    for (ASMTypeVariable tv : method.getTypeParameters()) {
      instance(CONCEPTS.TypeVariableDeclaration$4Y);
    }
    for (ASMTypeVariable tv : method.getTypeParameters()) {
      if (!(tv instanceof ASMFormalTypeParameter)) {
        continue;
      }
      ASMFormalTypeParameter tp = (ASMFormalTypeParameter) tv;
      if (tp.getClassBound() != null) {
        getTypeByASMType(tp.getClassBound());
      }
      for (ASMType act : tp.getInterfaceBounds()) {
        getTypeByASMType(act);
      }
    }
  }
  private void updateAnnotations(ASMClass ac) {
    for (ASMAnnotation annotation : ac.getAnnotations()) {
      createAnnotation(annotation);
    }
  }
  private void updateExtendsForInterface(ASMClass ac) {
    for (ASMType type : ac.getGenericInterfaces()) {
      getTypeByASMType(type);
    }
  }
  private void updateExtendsAndImplements(ASMClass ac) {
    ASMType refSuperclass = ac.getGenericSuperclass();
    if (refSuperclass != null) {
      getTypeByASMType(refSuperclass);
    }
    for (ASMType type : ac.getGenericInterfaces()) {
      getTypeByASMType(type);
    }
  }
  private void updateInstanceFields(ASMClass refCls) {
    for (ASMField field : refCls.getDeclaredFields()) {
      if (field.isStatic()) {
        continue;
      }
      if (field.isSynthetic()) {
        continue;
      }
      instance(CONCEPTS.FieldDeclaration$ie);
      createVisibility(field);
      getTypeByASMType(field.getGenericType());
      for (ASMAnnotation annotation : field.getAnnotations()) {
        createAnnotation(annotation);
      }
    }
  }
  private void updateStaticFields(ASMClass ac) {
    for (ASMField field : ac.getDeclaredFields()) {
      if (!(field.isStatic())) {
        continue;
      }
      if (field.isSynthetic()) {
        continue;
      }
      if (field.isEnumConstant()) {
        instance(CONCEPTS.EnumConstantDeclaration$MW);
      } else {
        instance(CONCEPTS.StaticFieldDeclaration$jR);
        createVisibility(field);
        getTypeByASMType(field.getGenericType());
        for (ASMAnnotation annotation : field.getAnnotations()) {
          createAnnotation(annotation);
        }
        if (field.isFinal()) {
          if (field.hasValue()) {
            Object value = field.getValue();
            if (value instanceof Integer) {
              instance(CONCEPTS.IntegerConstant$Na);
            } else if (value instanceof String) {
              instance(CONCEPTS.StringLiteral$xu);
            }
          }
        }
      }
    }
  }
  private void updateAnnotationMethods(ASMClass refCls) {
    for (ASMMethod m : refCls.getDeclaredMethods()) {
      instance(CONCEPTS.AnnotationMethodDeclaration$4O);
      getTypeByASMType(m.getGenericReturnType());
      instance(CONCEPTS.PublicVisibility$R0);
      if (m.getAnnotationDefault() != null) {
        getAnnotationValue(m.getAnnotationDefault());
      }
    }
  }
  private void updateConstructors(ASMClass ac) {
    for (ASMMethod c : ac.getDeclaredConstructors()) {
      if (c.isSynthetic()) {
        continue;
      }

      instance(CONCEPTS.ConstructorDeclaration$yG);
      createVisibility(c);
      instance(CONCEPTS.StubStatementList$v6);

      for (ASMTypeVariable tv : c.getTypeParameters()) {
        instance(CONCEPTS.TypeVariableDeclaration$4Y);
      }

      {
        Iterator<ASMType> pt_it = ListSequence.fromList(c.getGenericParameterTypes()).iterator();
        Iterator<String> pn_it = ListSequence.fromList(c.getParameterNames()).iterator();
        Iterator<List<ASMAnnotation>> pa_it = ListSequence.fromList(c.getParameterAnnotations()).iterator();
        ASMType pt_var;
        String pn_var;
        List<ASMAnnotation> pa_var;
        while (pt_it.hasNext() && pn_it.hasNext() && pa_it.hasNext()) {
          pt_var = pt_it.next();
          pn_var = pn_it.next();
          pa_var = pa_it.next();
          if (!(ac.isStatic()) && c.getGenericParameterTypes().get(0) == pt_var) {
            continue;
          }

          instance(CONCEPTS.ParameterDeclaration$RG);
          getTypeByASMType(pt_var);
          addAnnotationsToParameter(pa_var);
        }
      }
      for (ASMAnnotation annotation : c.getAnnotations()) {
        createAnnotation(annotation);
      }
      for (ASMType exception : c.getExceptionTypes()) {
        getTypeByASMType(exception);
      }
    }
  }
  private void updateInstanceMethods(ASMClass ac) {
    for (ASMMethod m : ac.getDeclaredMethods()) {
      if (m.isStatic()) {
        continue;
      }
      if (m.isBridge()) {
        continue;
      }
      if (m.isCompilerGenerated()) {
        continue;
      }

      instance(CONCEPTS.InstanceMethodDeclaration$39);
      createVisibility(m);
      updateBaseMethod(m);
    }
  }
  private void updateStaticMethods(ASMClass ac, ClassifierKind kind) {
    for (ASMMethod m : ac.getDeclaredMethods()) {
      if (!(m.isStatic())) {
        continue;
      }
      if (m.isCompilerGenerated()) {
        continue;
      }
      if (kind == ClassifierKind.ENUM && isGeneratedEnumMethod(m)) {
        continue;
      }

      instance(CONCEPTS.StaticMethodDeclaration$FJ);
      createVisibility(m);
      updateBaseMethod(m);
    }
  }
  private void updateBaseMethod(ASMMethod m) {
    instance(CONCEPTS.StubStatementList$v6);
    updateTypeVariables(m);
    getTypeByASMType(m.getGenericReturnType());
    {
      Iterator<ASMType> pt_it = ListSequence.fromList(m.getGenericParameterTypes()).iterator();
      Iterator<String> pn_it = ListSequence.fromList(m.getParameterNames()).iterator();
      Iterator<List<ASMAnnotation>> pa_it = ListSequence.fromList(m.getParameterAnnotations()).iterator();
      ASMType pt_var;
      String pn_var;
      List<ASMAnnotation> pa_var;
      while (pt_it.hasNext() && pn_it.hasNext() && pa_it.hasNext()) {
        pt_var = pt_it.next();
        pn_var = pn_it.next();
        pa_var = pa_it.next();
        instance(CONCEPTS.ParameterDeclaration$RG);
        getTypeByASMType(pt_var);
        addAnnotationsToParameter(pa_var);
      }
    }
    for (ASMType exception : m.getExceptionTypes()) {
      getTypeByASMType(exception);
    }
    for (ASMAnnotation annotation : m.getAnnotations()) {
      createAnnotation(annotation);
    }
  }
  private boolean isGeneratedEnumMethod(ASMMethod m) {
    if (m.getName().equals("values") && m.getParameterTypes().isEmpty()) {
      return true;
    }
    if (m.getName().equals("valueOf") && m.getParameterTypes().size() == 1 && m.getParameterTypes().get(0) instanceof ASMClassType) {
      ASMClassType type = (ASMClassType) m.getParameterTypes().get(0);
      return type.getName().equals("java.lang.String");
    }
    return false;
  }
  protected void createVisibility(ASMMethod m) {
    if (m.isPublic()) {
      instance(CONCEPTS.PublicVisibility$R0);
    } else if (m.isPrivate()) {
      instance(CONCEPTS.PrivateVisibility$l0);
    } else if (m.isProtected()) {
      instance(CONCEPTS.ProtectedVisibility$hr);
    }
  }
  protected void createVisibility(ASMField f) {
    if (f.isPublic()) {
      instance(CONCEPTS.PublicVisibility$R0);
    } else if (f.isPrivate()) {
      instance(CONCEPTS.PrivateVisibility$l0);
    } else if (f.isProtected()) {
      instance(CONCEPTS.ProtectedVisibility$hr);
    }
  }
  private void addAnnotationsToParameter(List<ASMAnnotation> anns) {
    ListSequence.fromList(anns).visitAll((it) -> createAnnotation(it));
  }
  private void createAnnotation(ASMAnnotation annotation) {
    instance(CONCEPTS.AnnotationInstance$yl);
    ASMClassType c = (ASMClassType) annotation.getType();
    addClassifierReference(c);
    Map<String, Object> values = ((Map<String, Object>) annotation.getValues());
    for (String key : MapSequence.fromMap(values).keySet()) {
      instance(CONCEPTS.AnnotationInstanceValue$T7);
      getAnnotationValue(MapSequence.fromMap(values).get(key));
      addAnnotationMethodReference(c, key);
    }
  }
  private void getAnnotationValue(Object value) {
    if (value instanceof Integer) {
      instance(CONCEPTS.IntegerConstant$Na);
    } else if (value instanceof Byte) {
      instance(CONCEPTS.IntegerConstant$Na);
    } else if (value instanceof Short) {
      instance(CONCEPTS.IntegerConstant$Na);
    } else if (value instanceof Boolean) {
      instance(CONCEPTS.BooleanConstant$n4);
    } else if (value instanceof Character) {
      instance(CONCEPTS.CharConstant$Y4);
    } else if (value instanceof Long) {
      instance(CONCEPTS.LongLiteral$y2);
    } else if (value instanceof Float) {
      instance(CONCEPTS.FloatingPointConstant$3o);
    } else if (value instanceof Double) {
      instance(CONCEPTS.FloatingPointConstant$3o);
    } else if (value instanceof String) {
      instance(CONCEPTS.StringLiteral$xu);
    } else if (value instanceof ASMAnnotation) {
      createAnnotation((ASMAnnotation) value);
      instance(CONCEPTS.AnnotationInstance$yl);
    } else if (value instanceof ASMPrimitiveType) {
      getTypeByASMType((ASMPrimitiveType) value);
      instance(CONCEPTS.PrimitiveClassExpression$gf);
    } else if (value instanceof List) {
      List<Object> list = (List<Object>) value;
      instance(CONCEPTS.ArrayLiteral$Ey);
      ListSequence.fromList(list).visitAll((it) -> getAnnotationValue(it));
    } else if (value instanceof ASMEnumValue) {
      ASMEnumValue enumValue = (ASMEnumValue) value;
      ASMClassType c = (ASMClassType) enumValue.getType();
      instance(CONCEPTS.EnumConstantReference$kA);
      addClassifierReference(c);
      addEnumConstReference(enumValue);
    } else if (value instanceof ASMClassType) {
      instance(CONCEPTS.ClassifierClassExpression$lN);
      addClassifierReference((ASMClassType) value);
    }
  }
  private void getTypeByASMType(ASMType type) {
    if (type == ASMPrimitiveType.BOOLEAN) {
      instance(CONCEPTS.BooleanType$_u);
    } else if (type == ASMPrimitiveType.BYTE) {
      instance(CONCEPTS.ByteType$Ms);
    } else if (type == ASMPrimitiveType.SHORT) {
      instance(CONCEPTS.ShortType$ro);
    } else if (type == ASMPrimitiveType.INT) {
      instance(CONCEPTS.IntegerType$7a);
    } else if (type == ASMPrimitiveType.LONG) {
      instance(CONCEPTS.LongType$5X);
    } else if (type == ASMPrimitiveType.FLOAT) {
      instance(CONCEPTS.FloatType$up);
    } else if (type == ASMPrimitiveType.DOUBLE) {
      instance(CONCEPTS.DoubleType$x0);
    } else if (type == ASMPrimitiveType.VOID) {
      instance(CONCEPTS.VoidType$BF);
    } else if (type == ASMPrimitiveType.CHAR) {
      instance(CONCEPTS.CharType$JQ);
    } else if (type instanceof ASMArrayType) {
      getTypeByASMType(((ASMArrayType) type).getElementType());
      instance(CONCEPTS.ArrayType$rh);
    } else if (type instanceof ASMVarArgType) {
      getTypeByASMType(((ASMVarArgType) type).getElementType());
      instance(CONCEPTS.VariableArityType$KF);
    } else if (type instanceof ASMTypeVariable) {
      instance(CONCEPTS.TypeVariableReference$WL);
      // usages handled on upper level as for resolve we should load model
      // another variant is just to search for occurence in the same model
    } else if (type instanceof ASMClassType) {
      ASMClassType c = (ASMClassType) type;
      instance(CONCEPTS.ClassifierType$bL);
      addClassifierReference(c);
    } else if (type instanceof ASMParameterizedType) {
      ASMParameterizedType pt = (ASMParameterizedType) type;
      getTypeByASMType(pt.getRawType());
      addTypeParameters(pt.getActualTypeArguments());
    } else if (type instanceof ASMExtendsType) {
      ASMExtendsType e = (ASMExtendsType) type;
      if (e.getBound() instanceof ASMClassType) {
        ASMClassType ct = (ASMClassType) e.getBound();
        if (ct.getName().equals("java.lang.Object")) {
          instance(CONCEPTS.WildCardType$uV);
          return;
        }
      }
      instance(CONCEPTS.UpperBoundType$RS);
      getTypeByASMType(e.getBound());
    } else if (type instanceof ASMSuperType) {
      ASMSuperType e = (ASMSuperType) type;
      instance(CONCEPTS.LowerBoundType$nl);
      getTypeByASMType(e.getBound());
    } else if (type instanceof ASMUnboundedType) {
      instance(CONCEPTS.WildCardType$uV);
    } else {
      instance(CONCEPTS.Type$bu);
    }
  }
  private void addTypeParameters(List<? extends ASMType> typeParameters) {
    for (ASMType tv : typeParameters) {
      getTypeByASMType(tv);
    }
  }
  private void addClassifierReference(ASMClassType clsType) {
    SNodeId nodeId = ASMNodeId.createId(clsType.getName());
    ref(nodeId);
    modelRef(NameUtil.namespaceFromLongName(clsType.getName()));
  }
  private void addAnnotationMethodReference(ASMClassType annotationType, String method) {
    SNodeId nodeId = ASMNodeId.createAnnotationMethodId(annotationType.getName(), method);
    ref(nodeId);
  }
  private void addEnumConstReference(ASMEnumValue enumValue) {
    ASMClassType classType = (ASMClassType) enumValue.getType();
    SNodeId nodeId = ASMNodeId.createFieldId(classType.getName(), enumValue.getConstant());
    ref(nodeId);
  }

  private static final class CONCEPTS {
    /*package*/ static final SConcept ClassConcept$bK = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8c108ca66L, "jetbrains.mps.baseLanguage.structure.ClassConcept");
    /*package*/ static final SConcept Interface$db = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x101edd46144L, "jetbrains.mps.baseLanguage.structure.Interface");
    /*package*/ static final SConcept Annotation$he = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x114a69dc80cL, "jetbrains.mps.baseLanguage.structure.Annotation");
    /*package*/ static final SConcept EnumClass$Vk = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xfc367070a5L, "jetbrains.mps.baseLanguage.structure.EnumClass");
    /*package*/ static final SConcept PublicVisibility$R0 = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x10af9581ff1L, "jetbrains.mps.baseLanguage.structure.PublicVisibility");
    /*package*/ static final SConcept TypeVariableDeclaration$4Y = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x1024639ed74L, "jetbrains.mps.baseLanguage.structure.TypeVariableDeclaration");
    /*package*/ static final SConcept FieldDeclaration$ie = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8c108ca68L, "jetbrains.mps.baseLanguage.structure.FieldDeclaration");
    /*package*/ static final SConcept StaticFieldDeclaration$jR = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf93c84351fL, "jetbrains.mps.baseLanguage.structure.StaticFieldDeclaration");
    /*package*/ static final SConcept IntegerConstant$Na = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8cc59b314L, "jetbrains.mps.baseLanguage.structure.IntegerConstant");
    /*package*/ static final SConcept StringLiteral$xu = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf93d565d10L, "jetbrains.mps.baseLanguage.structure.StringLiteral");
    /*package*/ static final SConcept EnumConstantDeclaration$MW = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xfc367388b3L, "jetbrains.mps.baseLanguage.structure.EnumConstantDeclaration");
    /*package*/ static final SConcept AnnotationMethodDeclaration$4O = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x114a6a17a27L, "jetbrains.mps.baseLanguage.structure.AnnotationMethodDeclaration");
    /*package*/ static final SConcept ConstructorDeclaration$yG = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8cc56b204L, "jetbrains.mps.baseLanguage.structure.ConstructorDeclaration");
    /*package*/ static final SConcept StubStatementList$v6 = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x4975dc2bdcfa0c49L, "jetbrains.mps.baseLanguage.structure.StubStatementList");
    /*package*/ static final SConcept ParameterDeclaration$RG = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8c77f1e94L, "jetbrains.mps.baseLanguage.structure.ParameterDeclaration");
    /*package*/ static final SConcept InstanceMethodDeclaration$39 = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8cc56b21dL, "jetbrains.mps.baseLanguage.structure.InstanceMethodDeclaration");
    /*package*/ static final SConcept StaticMethodDeclaration$FJ = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xfbbebabf0aL, "jetbrains.mps.baseLanguage.structure.StaticMethodDeclaration");
    /*package*/ static final SConcept PrivateVisibility$l0 = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x10af9586f0cL, "jetbrains.mps.baseLanguage.structure.PrivateVisibility");
    /*package*/ static final SConcept ProtectedVisibility$hr = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x10af958b686L, "jetbrains.mps.baseLanguage.structure.ProtectedVisibility");
    /*package*/ static final SConcept AnnotationInstance$yl = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x114a6b4ccabL, "jetbrains.mps.baseLanguage.structure.AnnotationInstance");
    /*package*/ static final SConcept AnnotationInstanceValue$T7 = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x114a71b1af4L, "jetbrains.mps.baseLanguage.structure.AnnotationInstanceValue");
    /*package*/ static final SConcept BooleanConstant$n4 = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8cc56b201L, "jetbrains.mps.baseLanguage.structure.BooleanConstant");
    /*package*/ static final SConcept CharConstant$Y4 = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x1177d44b21bL, "jetbrains.mps.baseLanguage.structure.CharConstant");
    /*package*/ static final SConcept LongLiteral$y2 = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x3b418722717710b4L, "jetbrains.mps.baseLanguage.structure.LongLiteral");
    /*package*/ static final SConcept FloatingPointConstant$3o = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x102cb19a434L, "jetbrains.mps.baseLanguage.structure.FloatingPointConstant");
    /*package*/ static final SConcept PrimitiveClassExpression$gf = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x3f57ea36bd70a4e1L, "jetbrains.mps.baseLanguage.structure.PrimitiveClassExpression");
    /*package*/ static final SConcept ArrayLiteral$Ey = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x114a770dc0dL, "jetbrains.mps.baseLanguage.structure.ArrayLiteral");
    /*package*/ static final SConcept EnumConstantReference$kA = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xfc37588bc8L, "jetbrains.mps.baseLanguage.structure.EnumConstantReference");
    /*package*/ static final SConcept ClassifierClassExpression$lN = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x103fb730c14L, "jetbrains.mps.baseLanguage.structure.ClassifierClassExpression");
    /*package*/ static final SConcept BooleanType$_u = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf940d6513eL, "jetbrains.mps.baseLanguage.structure.BooleanType");
    /*package*/ static final SConcept ByteType$Ms = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf940d5b617L, "jetbrains.mps.baseLanguage.structure.ByteType");
    /*package*/ static final SConcept ShortType$ro = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf940cc380dL, "jetbrains.mps.baseLanguage.structure.ShortType");
    /*package*/ static final SConcept IntegerType$7a = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf940d22479L, "jetbrains.mps.baseLanguage.structure.IntegerType");
    /*package*/ static final SConcept LongType$5X = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8cc67c7f3L, "jetbrains.mps.baseLanguage.structure.LongType");
    /*package*/ static final SConcept FloatType$up = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf940d327fdL, "jetbrains.mps.baseLanguage.structure.FloatType");
    /*package*/ static final SConcept DoubleType$x0 = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf940d451a6L, "jetbrains.mps.baseLanguage.structure.DoubleType");
    /*package*/ static final SConcept VoidType$BF = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8cc6bf96dL, "jetbrains.mps.baseLanguage.structure.VoidType");
    /*package*/ static final SConcept CharType$JQ = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf940d4f826L, "jetbrains.mps.baseLanguage.structure.CharType");
    /*package*/ static final SConcept ArrayType$rh = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf940d819f7L, "jetbrains.mps.baseLanguage.structure.ArrayType");
    /*package*/ static final SConcept VariableArityType$KF = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x11c08f42e7bL, "jetbrains.mps.baseLanguage.structure.VariableArityType");
    /*package*/ static final SConcept TypeVariableReference$WL = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x102467229d8L, "jetbrains.mps.baseLanguage.structure.TypeVariableReference");
    /*package*/ static final SConcept ClassifierType$bL = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x101de48bf9eL, "jetbrains.mps.baseLanguage.structure.ClassifierType");
    /*package*/ static final SConcept WildCardType$uV = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x110dae5f4a3L, "jetbrains.mps.baseLanguage.structure.WildCardType");
    /*package*/ static final SConcept UpperBoundType$RS = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x110daeaa84aL, "jetbrains.mps.baseLanguage.structure.UpperBoundType");
    /*package*/ static final SConcept LowerBoundType$nl = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x110dae9d53dL, "jetbrains.mps.baseLanguage.structure.LowerBoundType");
    /*package*/ static final SConcept Type$bu = MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8c37f506dL, "jetbrains.mps.baseLanguage.structure.Type");
  }
}
