diff --git a/src/main/java/org/apache/xmlbeans/impl/schema/SchemaContainer.java b/src/main/java/org/apache/xmlbeans/impl/schema/SchemaContainer.java
index e3fe3f5..7a48ead 100644
--- a/src/main/java/org/apache/xmlbeans/impl/schema/SchemaContainer.java
+++ b/src/main/java/org/apache/xmlbeans/impl/schema/SchemaContainer.java
@@ -15,34 +15,24 @@
 
 package org.apache.xmlbeans.impl.schema;
 
+import org.apache.xmlbeans.*;
+
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.stream.Collectors;
 
-import org.apache.xmlbeans.SchemaAnnotation;
-import org.apache.xmlbeans.SchemaAttributeGroup;
-import org.apache.xmlbeans.SchemaComponent;
-import org.apache.xmlbeans.SchemaGlobalAttribute;
-import org.apache.xmlbeans.SchemaGlobalElement;
-import org.apache.xmlbeans.SchemaIdentityConstraint;
-import org.apache.xmlbeans.SchemaModelGroup;
-import org.apache.xmlbeans.SchemaType;
-import org.apache.xmlbeans.SchemaTypeSystem;
-
-/*package*/ class SchemaContainer
-{
+/*package*/ class SchemaContainer {
     // The namespace that this is the container for
     // TODO(radup) In the future, I think the right approach is one container
     // per file instead of per namespace, but per namespace is easier for now
-    private String _namespace;
+    private final String _namespace;
 
-    SchemaContainer(String namespace)
-    {
+    SchemaContainer(String namespace) {
         _namespace = namespace;
     }
 
-    String getNamespace()
-    {
+    String getNamespace() {
         return _namespace;
     }
 
@@ -55,13 +45,11 @@
     // at the same time providing the mechanism through which
     // we can "move" SchemaTypes from one SchemaTypeSystem to another
     // via incremental compilation
-    synchronized SchemaTypeSystem getTypeSystem()
-    {
+    synchronized SchemaTypeSystem getTypeSystem() {
         return _typeSystem;
     }
 
-    synchronized void setTypeSystem(SchemaTypeSystem typeSystem)
-    {
+    synchronized void setTypeSystem(SchemaTypeSystem typeSystem) {
         _typeSystem = typeSystem;
     }
 
@@ -73,138 +61,164 @@
     // between typesystems.
     boolean _immutable;
 
-    synchronized void setImmutable()
-    {
+    synchronized void setImmutable() {
         _immutable = true;
     }
 
-    synchronized void unsetImmutable()
-    {
+    synchronized void unsetImmutable() {
         _immutable = false;
     }
 
-    private void check_immutable()
-    {
-        if (_immutable)
+    private void check_immutable() {
+        if (_immutable) {
             throw new IllegalStateException("Cannot add components to immutable SchemaContainer");
+        }
     }
 
     // Data
     // TODO(radup) unmodifiableList() is not really necessary, since this
     // is package-level access and code in this package should do the "right thing"
     // Global Elements
-    private List/*<SchemaGlobalElement.Ref>*/ _globalElements = new ArrayList();
+    private final List<SchemaGlobalElement.Ref> _globalElements = new ArrayList<>();
 
-    void addGlobalElement(SchemaGlobalElement.Ref e)
-    {   check_immutable(); _globalElements.add(e); }
+    void addGlobalElement(SchemaGlobalElement.Ref e) {
+        check_immutable();
+        _globalElements.add(e);
+    }
 
-    List globalElements()
-    {   return getComponentList(_globalElements); }
+    List<SchemaGlobalElement> globalElements() {
+        return _globalElements.stream().map(SchemaGlobalElement.Ref::get).collect(Collectors.toList());
+    }
 
     // Global Attributes
-    private List/*<SchemaGlobalAttribute.Ref>*/ _globalAttributes = new ArrayList();
+    private final List<SchemaGlobalAttribute.Ref> _globalAttributes = new ArrayList<>();
 
-    void addGlobalAttribute(SchemaGlobalAttribute.Ref a)
-    {   check_immutable(); _globalAttributes.add(a); }
+    void addGlobalAttribute(SchemaGlobalAttribute.Ref a) {
+        check_immutable();
+        _globalAttributes.add(a);
+    }
 
-    List globalAttributes()
-    {   return getComponentList(_globalAttributes); }
+    List<SchemaGlobalAttribute> globalAttributes() {
+        return _globalAttributes.stream().map(SchemaGlobalAttribute.Ref::get).collect(Collectors.toList());
+    }
 
     // Model Groups
-    private List/*<SchemaModelGroup.Ref>*/ _modelGroups = new ArrayList();
+    private final List<SchemaModelGroup.Ref> _modelGroups = new ArrayList<>();
 
-    void addModelGroup(SchemaModelGroup.Ref g)
-    {   check_immutable(); _modelGroups.add(g); }
+    void addModelGroup(SchemaModelGroup.Ref g) {
+        check_immutable();
+        _modelGroups.add(g);
+    }
 
-    List modelGroups()
-    {   return getComponentList(_modelGroups); }
+    List<SchemaModelGroup> modelGroups() {
+        return _modelGroups.stream().map(SchemaModelGroup.Ref::get).collect(Collectors.toList());
+    }
 
     // Redefined Model Groups
-    private List/*<SchemaModelGroup.Ref>*/ _redefinedModelGroups = new ArrayList();
+    private final List<SchemaModelGroup.Ref> _redefinedModelGroups = new ArrayList<>();
 
-    void addRedefinedModelGroup(SchemaModelGroup.Ref g)
-    {   check_immutable(); _redefinedModelGroups.add(g); }
+    void addRedefinedModelGroup(SchemaModelGroup.Ref g) {
+        check_immutable();
+        _redefinedModelGroups.add(g);
+    }
 
-    List redefinedModelGroups()
-    {   return getComponentList(_redefinedModelGroups); }
+    List<SchemaModelGroup> redefinedModelGroups() {
+        return _redefinedModelGroups.stream().map(SchemaModelGroup.Ref::get).collect(Collectors.toList());
+    }
 
     // Attribute Groups
-    private List/*<SchemaAttributeGroup.Ref>*/ _attributeGroups = new ArrayList();
+    private final List<SchemaAttributeGroup.Ref> _attributeGroups = new ArrayList<>();
 
-    void addAttributeGroup(SchemaAttributeGroup.Ref g)
-    {   check_immutable(); _attributeGroups.add(g); }
+    void addAttributeGroup(SchemaAttributeGroup.Ref g) {
+        check_immutable();
+        _attributeGroups.add(g);
+    }
 
-    List attributeGroups()
-    {   return getComponentList(_attributeGroups); }
+    List<SchemaAttributeGroup> attributeGroups() {
+        return _attributeGroups.stream().map(SchemaAttributeGroup.Ref::get).collect(Collectors.toList());
+    }
 
     // Redefined Attribute Groups
-    private List/*<SchemaAttributeGroup.Ref>*/ _redefinedAttributeGroups = new ArrayList();
+    private final List<SchemaAttributeGroup.Ref> _redefinedAttributeGroups = new ArrayList<>();
 
-    void addRedefinedAttributeGroup(SchemaAttributeGroup.Ref g)
-    {   check_immutable(); _redefinedAttributeGroups.add(g); }
+    void addRedefinedAttributeGroup(SchemaAttributeGroup.Ref g) {
+        check_immutable();
+        _redefinedAttributeGroups.add(g);
+    }
 
-    List redefinedAttributeGroups()
-    {   return getComponentList(_redefinedAttributeGroups); }
+    List<SchemaAttributeGroup> redefinedAttributeGroups() {
+        return _redefinedAttributeGroups.stream().map(SchemaAttributeGroup.Ref::get).collect(Collectors.toList());
+    }
 
     // Global Types
-    private List/*<SchemaType.Ref>*/ _globalTypes = new ArrayList();
+    private final List<SchemaType.Ref> _globalTypes = new ArrayList<>();
 
-    void addGlobalType(SchemaType.Ref t)
-    {   check_immutable(); _globalTypes.add(t); }
+    void addGlobalType(SchemaType.Ref t) {
+        check_immutable();
+        _globalTypes.add(t);
+    }
 
-    List globalTypes()
-    {   return getComponentList(_globalTypes); }
+    List<SchemaType> globalTypes() {
+        return _globalTypes.stream().map(SchemaType.Ref::get).collect(Collectors.toList());
+    }
 
     // Redefined Global Types
-    private List/*<SchemaType.Ref>*/ _redefinedGlobalTypes = new ArrayList();
+    private final List<SchemaType.Ref> _redefinedGlobalTypes = new ArrayList<>();
 
-    void addRedefinedType(SchemaType.Ref t)
-    {   check_immutable(); _redefinedGlobalTypes.add(t); }
+    void addRedefinedType(SchemaType.Ref t) {
+        check_immutable();
+        _redefinedGlobalTypes.add(t);
+    }
 
-    List redefinedGlobalTypes()
-    {   return getComponentList(_redefinedGlobalTypes); }
+    List<SchemaType> redefinedGlobalTypes() {
+        return _redefinedGlobalTypes.stream().map(SchemaType.Ref::get).collect(Collectors.toList());
+    }
 
     // Document Types
-    private List/*<SchemaType.Ref>*/ _documentTypes = new ArrayList();
+    private final List<SchemaType.Ref> _documentTypes = new ArrayList<>();
 
-    void addDocumentType(SchemaType.Ref t)
-    {   check_immutable(); _documentTypes.add(t); }
+    void addDocumentType(SchemaType.Ref t) {
+        check_immutable();
+        _documentTypes.add(t);
+    }
 
-    List documentTypes()
-    {   return getComponentList(_documentTypes); }
+    List<SchemaType> documentTypes() {
+        return _documentTypes.stream().map(SchemaType.Ref::get).collect(Collectors.toList());
+    }
 
     // Attribute Types
-    private List/*<SchemaType.Ref>*/ _attributeTypes = new ArrayList();
+    private final List<SchemaType.Ref> _attributeTypes = new ArrayList<>();
 
-    void addAttributeType(SchemaType.Ref t)
-    {   check_immutable(); _attributeTypes.add(t); }
+    void addAttributeType(SchemaType.Ref t) {
+        check_immutable();
+        _attributeTypes.add(t);
+    }
 
-    List attributeTypes()
-    {   return getComponentList(_attributeTypes); }
+    List<SchemaType> attributeTypes() {
+        return _attributeTypes.stream().map(SchemaType.Ref::get).collect(Collectors.toList());
+    }
 
     // Identity Constraints
-    private List/*<SchemaIdentityConstraint.Ref>*/ _identityConstraints = new ArrayList();
+    private final List<SchemaIdentityConstraint.Ref> _identityConstraints = new ArrayList<>();
 
-    void addIdentityConstraint(SchemaIdentityConstraint.Ref c)
-    {   check_immutable(); _identityConstraints.add(c); }
+    void addIdentityConstraint(SchemaIdentityConstraint.Ref c) {
+        check_immutable();
+        _identityConstraints.add(c);
+    }
 
-    List identityConstraints()
-    {   return getComponentList(_identityConstraints); }
+    List<SchemaIdentityConstraint> identityConstraints() {
+        return _identityConstraints.stream().map(SchemaIdentityConstraint.Ref::get).collect(Collectors.toList());
+    }
 
     // Annotations
-    private List/*<SchemaAnnotation>*/ _annotations = new ArrayList();
+    private final List<SchemaAnnotation> _annotations = new ArrayList<>();
 
-    void addAnnotation(SchemaAnnotation a)
-    {   check_immutable(); _annotations.add(a); }
+    void addAnnotation(SchemaAnnotation a) {
+        check_immutable();
+        _annotations.add(a);
+    }
 
-    List annotations()
-    {   return Collections.unmodifiableList(_annotations); }
-
-    private List getComponentList(List referenceList)
-    {
-        List result = new ArrayList();
-        for (int i = 0; i < referenceList.size(); i ++)
-            result.add(((SchemaComponent.Ref) referenceList.get(i)).getComponent());
-        return Collections.unmodifiableList(result);
+    List<SchemaAnnotation> annotations() {
+        return Collections.unmodifiableList(_annotations);
     }
 }
diff --git a/src/main/java/org/apache/xmlbeans/impl/schema/StscChecker.java b/src/main/java/org/apache/xmlbeans/impl/schema/StscChecker.java
index caf6ceb..375f37f 100644
--- a/src/main/java/org/apache/xmlbeans/impl/schema/StscChecker.java
+++ b/src/main/java/org/apache/xmlbeans/impl/schema/StscChecker.java
@@ -15,39 +15,16 @@
 
 package org.apache.xmlbeans.impl.schema;
 
-import org.apache.xmlbeans.SchemaType;
-import org.apache.xmlbeans.SchemaParticle;
-import org.apache.xmlbeans.XmlError;
-import org.apache.xmlbeans.XmlObject;
-import org.apache.xmlbeans.XmlOptions;
-import org.apache.xmlbeans.SchemaLocalElement;
-import org.apache.xmlbeans.SchemaIdentityConstraint;
-import org.apache.xmlbeans.SchemaAttributeModel;
-import org.apache.xmlbeans.SchemaLocalAttribute;
-import org.apache.xmlbeans.SchemaGlobalElement;
-import org.apache.xmlbeans.XmlID;
-import org.apache.xmlbeans.XmlAnySimpleType;
-import org.apache.xmlbeans.XmlErrorCodes;
-import org.apache.xmlbeans.XmlNOTATION;
-import org.apache.xmlbeans.XmlString;
-import org.apache.xmlbeans.impl.common.XBeanDebug;
+import org.apache.xmlbeans.*;
 import org.apache.xmlbeans.impl.common.QNameHelper;
+import org.apache.xmlbeans.impl.common.XBeanDebug;
 
 import javax.xml.namespace.QName;
-import java.util.List;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Set;
 import java.math.BigInteger;
+import java.util.*;
 
-public class StscChecker
-{
-    public static void checkAll()
-    {
+public class StscChecker {
+    public static void checkAll() {
         // walk the tree of types
         StscState state = StscState.get();
 
@@ -57,138 +34,123 @@
         allSeenTypes.addAll(Arrays.asList(state.redefinedGlobalTypes()));
         allSeenTypes.addAll(Arrays.asList(state.globalTypes()));
 
-        for (int i = 0; i < allSeenTypes.size(); i++)
-        {
-            SchemaType gType = (SchemaType)allSeenTypes.get(i);
+        for (int i = 0; i < allSeenTypes.size(); i++) {
+            SchemaType gType = (SchemaType) allSeenTypes.get(i);
             if (!state.noPvr() &&  // option to turn off particle restriction checking
-                !gType.isDocumentType()) // Don't check doc types for restriction. 
+                !gType.isDocumentType()) // Don't check doc types for restriction.
             {
-                checkRestriction((SchemaTypeImpl)gType);
+                checkRestriction((SchemaTypeImpl) gType);
             }
-            checkFields((SchemaTypeImpl)gType);
+            checkFields((SchemaTypeImpl) gType);
             allSeenTypes.addAll(Arrays.asList(gType.getAnonymousTypes()));
         }
 
         checkSubstitutionGroups(state.globalElements());
     }
-    
+
     /**
      * The following code checks rule #5 of http://www.w3.org/TR/xmlschema-1/#coss-ct
      * as well as attribute + element default/fixed validity. <p/>
      * Checks that xs:NOTATION is not used directly
      */
-    public static void checkFields(SchemaTypeImpl sType)
-    {
-        if (sType.isSimpleType())
+    public static void checkFields(SchemaTypeImpl sType) {
+        if (sType.isSimpleType()) {
             return;
-        
+        }
+
         XmlObject location = sType.getParseObject();
-        
+
         SchemaAttributeModel sAttrModel = sType.getAttributeModel();
-        if (sAttrModel != null)
-        {
-            SchemaLocalAttribute[] sAttrs  = sAttrModel.getAttributes();
+        if (sAttrModel != null) {
+            SchemaLocalAttribute[] sAttrs = sAttrModel.getAttributes();
             QName idAttr = null;
-            for (int i = 0; i < sAttrs.length; i++)
-            {
-                XmlObject attrLocation = ((SchemaLocalAttributeImpl)sAttrs[i])._parseObject;
-                if (XmlID.type.isAssignableFrom(sAttrs[i].getType()))
-                {
-                    if (idAttr == null)
-                    {
+            for (int i = 0; i < sAttrs.length; i++) {
+                XmlObject attrLocation = ((SchemaLocalAttributeImpl) sAttrs[i])._parseObject;
+                if (XmlID.type.isAssignableFrom(sAttrs[i].getType())) {
+                    if (idAttr == null) {
                         idAttr = sAttrs[i].getName();
-                    }
-                    else
-                    {
+                    } else {
                         StscState.get().error(XmlErrorCodes.ATTR_GROUP_PROPERTIES$TWO_IDS,
-                            new Object[]{ QNameHelper.pretty(idAttr), sAttrs[i].getName() },
+                            new Object[]{QNameHelper.pretty(idAttr), sAttrs[i].getName()},
                             attrLocation != null ? attrLocation : location);
                     }
-                    if (sAttrs[i].getDefaultText() != null)
-                    {
+                    if (sAttrs[i].getDefaultText() != null) {
                         StscState.get().error(XmlErrorCodes.ATTR_PROPERTIES$ID_FIXED_OR_DEFAULT,
                             null, attrLocation != null ? attrLocation : location);
                     }
-                }
-                else if (XmlNOTATION.type.isAssignableFrom(sAttrs[i].getType()))
-                {
-                    if (sAttrs[i].getType().getBuiltinTypeCode() == SchemaType.BTC_NOTATION)
-                    {
+                } else if (XmlNOTATION.type.isAssignableFrom(sAttrs[i].getType())) {
+                    if (sAttrs[i].getType().getBuiltinTypeCode() == SchemaType.BTC_NOTATION) {
                         StscState.get().recover(XmlErrorCodes.ATTR_NOTATION_TYPE_FORBIDDEN,
-                            new Object[]{ QNameHelper.pretty(sAttrs[i].getName()) },
+                            new Object[]{QNameHelper.pretty(sAttrs[i].getName())},
                             attrLocation != null ? attrLocation : location);
-                    }
-                    else
-                    {
-                        if (sAttrs[i].getType().getSimpleVariety() == SchemaType.UNION)
-                        {
+                    } else {
+                        if (sAttrs[i].getType().getSimpleVariety() == SchemaType.UNION) {
                             SchemaType[] members = sAttrs[i].getType().getUnionConstituentTypes();
-                            for (int j = 0; j < members.length; j++)
-                                if (members[j].getBuiltinTypeCode() == SchemaType.BTC_NOTATION)
+                            for (int j = 0; j < members.length; j++) {
+                                if (members[j].getBuiltinTypeCode() == SchemaType.BTC_NOTATION) {
                                     StscState.get().recover(XmlErrorCodes.ATTR_NOTATION_TYPE_FORBIDDEN,
-                                        new Object[]{ QNameHelper.pretty(sAttrs[i].getName()) },
+                                        new Object[]{QNameHelper.pretty(sAttrs[i].getName())},
                                         attrLocation != null ? attrLocation : location);
+                                }
+                            }
                         }
                         // Check that the Schema in which this is present doesn't have a targetNS
                         boolean hasNS;
-                        if (sType.isAttributeType())
+                        if (sType.isAttributeType()) {
                             hasNS = sAttrs[i].getName().getNamespaceURI().length() > 0;
-                        else
-                        {
+                        } else {
                             SchemaType t = sType;
-                            while (t.getOuterType() != null)
+                            while (t.getOuterType() != null) {
                                 t = t.getOuterType();
-                            if (t.isDocumentType())
+                            }
+                            if (t.isDocumentType()) {
                                 hasNS = t.getDocumentElementName().getNamespaceURI().length() > 0;
-                            else hasNS = t.getName().getNamespaceURI().length() > 0;
-                        }
-                        if (hasNS)
-                            StscState.get().warning(XmlErrorCodes.ATTR_COMPATIBILITY_TARGETNS,
-                                new Object[] {QNameHelper.pretty(sAttrs[i].getName()) },
-                                attrLocation != null ? attrLocation : location);
-                    }
-                }
-                else
-                {
-                    String valueConstraint = sAttrs[i].getDefaultText();
-                    if (valueConstraint != null)
-                    {
-                        try
-                        {
-                            XmlAnySimpleType val = sAttrs[i].getDefaultValue();
-                            if (!val.validate())
-                                throw new Exception();
-                            
-                            SchemaPropertyImpl sProp = (SchemaPropertyImpl)sType.getAttributeProperty(sAttrs[i].getName());
-                            if (sProp != null && sProp.getDefaultText() != null)
-                            {
-                                sProp.setDefaultValue(new XmlValueRef(val));
+                            } else {
+                                hasNS = t.getName().getNamespaceURI().length() > 0;
                             }
                         }
-                        catch (Exception e)
-                        {
+                        if (hasNS) {
+                            StscState.get().warning(XmlErrorCodes.ATTR_COMPATIBILITY_TARGETNS,
+                                new Object[]{QNameHelper.pretty(sAttrs[i].getName())},
+                                attrLocation != null ? attrLocation : location);
+                        }
+                    }
+                } else {
+                    String valueConstraint = sAttrs[i].getDefaultText();
+                    if (valueConstraint != null) {
+                        try {
+                            XmlAnySimpleType val = sAttrs[i].getDefaultValue();
+                            if (!val.validate()) {
+                                throw new Exception();
+                            }
+
+                            SchemaPropertyImpl sProp = (SchemaPropertyImpl) sType.getAttributeProperty(sAttrs[i].getName());
+                            if (sProp != null && sProp.getDefaultText() != null) {
+                                sProp.setDefaultValue(new XmlValueRef(val));
+                            }
+                        } catch (Exception e) {
                             // move to 'fixed' or 'default' attribute on the attribute definition
                             String constraintName = (sAttrs[i].isFixed() ? "fixed" : "default");
                             XmlObject constraintLocation = location;
-                            if (attrLocation != null)
-                            {
+                            if (attrLocation != null) {
                                 constraintLocation = attrLocation.selectAttribute("", constraintName);
-                                if (constraintLocation == null)
+                                if (constraintLocation == null) {
                                     constraintLocation = attrLocation;
+                                }
                             }
 
                             StscState.get().error(XmlErrorCodes.ATTR_PROPERTIES$CONSTRAINT_VALID,
-                                new Object[] { QNameHelper.pretty(sAttrs[i].getName()), 
-                                               constraintName,
-                                               valueConstraint,
-                                               QNameHelper.pretty(sAttrs[i].getType().getName()) },
+                                new Object[]{QNameHelper.pretty(sAttrs[i].getName()),
+                                    constraintName,
+                                    valueConstraint,
+                                    QNameHelper.pretty(sAttrs[i].getType().getName())},
                                 constraintLocation);
                         }
                     }
                 }
             }
         }
-        
+
         checkElementDefaults(sType.getContentModel(), location, sType);
     }
 
@@ -196,134 +158,115 @@
      * Checks the default values of elements.<p/>
      * Also checks that the type of elements is not one of ID, IDREF, IDREFS, ENTITY, ENTITIES or
      * NOTATION as per XMLSchema part 2.
+     *
      * @param model
      * @param location
      * @param parentType
      */
-    private static void checkElementDefaults(SchemaParticle model, XmlObject location, SchemaType parentType)
-    {
-        if (model == null)
+    private static void checkElementDefaults(SchemaParticle model, XmlObject location, SchemaType parentType) {
+        if (model == null) {
             return;
-        switch (model.getParticleType())
-        {
+        }
+        switch (model.getParticleType()) {
             case SchemaParticle.SEQUENCE:
             case SchemaParticle.CHOICE:
             case SchemaParticle.ALL:
                 SchemaParticle[] children = model.getParticleChildren();
-                for (int i = 0; i < children.length; i++)
-                {
+                for (int i = 0; i < children.length; i++) {
                     checkElementDefaults(children[i], location, parentType);
                 }
                 break;
-           case SchemaParticle.ELEMENT:
+            case SchemaParticle.ELEMENT:
                 String valueConstraint = model.getDefaultText();
-                if (valueConstraint != null)
-                {
-                    if (model.getType().isSimpleType() || model.getType().getContentType() == SchemaType.SIMPLE_CONTENT)
-                    {
-                        try
-                        {
+                if (valueConstraint != null) {
+                    if (model.getType().isSimpleType() || model.getType().getContentType() == SchemaType.SIMPLE_CONTENT) {
+                        try {
                             XmlAnySimpleType val = model.getDefaultValue();
                             XmlOptions opt = new XmlOptions();
                             opt.put(XmlOptions.VALIDATE_TEXT_ONLY);
-                            if (!val.validate(opt))
+                            if (!val.validate(opt)) {
                                 throw new Exception();
+                            }
 
-                            SchemaPropertyImpl sProp = (SchemaPropertyImpl)parentType.getElementProperty(model.getName());
-                            if (sProp != null && sProp.getDefaultText() != null)
-                            {
+                            SchemaPropertyImpl sProp = (SchemaPropertyImpl) parentType.getElementProperty(model.getName());
+                            if (sProp != null && sProp.getDefaultText() != null) {
                                 sProp.setDefaultValue(new XmlValueRef(val));
                             }
-                        }
-                        catch (Exception e)
-                        {
+                        } catch (Exception e) {
                             // move to 'fixed' or 'default' attribute on the element definition
                             String constraintName = (model.isFixed() ? "fixed" : "default");
                             XmlObject constraintLocation = location.selectAttribute("", constraintName);
 
                             StscState.get().error(XmlErrorCodes.ELEM_PROPERTIES$CONSTRAINT_VALID,
-                                new Object[] { QNameHelper.pretty(model.getName()),
-                                               constraintName,
-                                               valueConstraint,
-                                               QNameHelper.pretty(model.getType().getName()) },
-                                (constraintLocation==null ? location : constraintLocation));
+                                new Object[]{QNameHelper.pretty(model.getName()),
+                                    constraintName,
+                                    valueConstraint,
+                                    QNameHelper.pretty(model.getType().getName())},
+                                (constraintLocation == null ? location : constraintLocation));
                         }
-                    }
-                    else if (model.getType().getContentType() == SchemaType.MIXED_CONTENT)
-                    {
-                        if (!model.getType().getContentModel().isSkippable())
-                        {
+                    } else if (model.getType().getContentType() == SchemaType.MIXED_CONTENT) {
+                        if (!model.getType().getContentModel().isSkippable()) {
                             String constraintName = (model.isFixed() ? "fixed" : "default");
                             XmlObject constraintLocation = location.selectAttribute("", constraintName);
 
                             StscState.get().error(XmlErrorCodes.ELEM_DEFAULT_VALID$MIXED_AND_EMPTIABLE,
-                                new Object[] { QNameHelper.pretty(model.getName()),
-                                               constraintName,
-                                               valueConstraint },
-                                (constraintLocation==null ? location : constraintLocation));
-                        }
-                        else
-                        {
+                                new Object[]{QNameHelper.pretty(model.getName()),
+                                    constraintName,
+                                    valueConstraint},
+                                (constraintLocation == null ? location : constraintLocation));
+                        } else {
                             // Element Default Valid (Immediate): cos-valid-default.2.2.2
                             // no need to validate the value; type is a xs:string
-                            SchemaPropertyImpl sProp = (SchemaPropertyImpl)parentType.getElementProperty(model.getName());
-                            if (sProp != null && sProp.getDefaultText() != null)
-                            {
+                            SchemaPropertyImpl sProp = (SchemaPropertyImpl) parentType.getElementProperty(model.getName());
+                            if (sProp != null && sProp.getDefaultText() != null) {
                                 sProp.setDefaultValue(new XmlValueRef(XmlString.type.newValue(valueConstraint)));
                             }
                         }
-                    }
-                    else if (model.getType().getContentType() == SchemaType.ELEMENT_CONTENT)
-                    {
+                    } else if (model.getType().getContentType() == SchemaType.ELEMENT_CONTENT) {
                         XmlObject constraintLocation = location.selectAttribute("", "default");
                         StscState.get().error(XmlErrorCodes.ELEM_DEFAULT_VALID$SIMPLE_TYPE_OR_MIXED,
-                            new Object[] { QNameHelper.pretty(model.getName()),
-                                           valueConstraint,
-                                           "element" },
-                            (constraintLocation==null ? location : constraintLocation));
-                    }
-                    else if (model.getType().getContentType() == SchemaType.EMPTY_CONTENT)
-                    {
+                            new Object[]{QNameHelper.pretty(model.getName()),
+                                valueConstraint,
+                                "element"},
+                            (constraintLocation == null ? location : constraintLocation));
+                    } else if (model.getType().getContentType() == SchemaType.EMPTY_CONTENT) {
                         XmlObject constraintLocation = location.selectAttribute("", "default");
                         StscState.get().error(XmlErrorCodes.ELEM_DEFAULT_VALID$SIMPLE_TYPE_OR_MIXED,
-                            new Object[] { QNameHelper.pretty(model.getName()),
-                                           valueConstraint,
-                                           "empty" },
-                            (constraintLocation==null ? location : constraintLocation));
+                            new Object[]{QNameHelper.pretty(model.getName()),
+                                valueConstraint,
+                                "empty"},
+                            (constraintLocation == null ? location : constraintLocation));
                     }
                 }
                 // Checks if the type is one of the "attribute-specific" types
                 String warningType = null;
-                if (BuiltinSchemaTypeSystem.ST_ID.isAssignableFrom(model.getType()))
+                if (BuiltinSchemaTypeSystem.ST_ID.isAssignableFrom(model.getType())) {
                     warningType = BuiltinSchemaTypeSystem.ST_ID.getName().getLocalPart();
-                else if (BuiltinSchemaTypeSystem.ST_IDREF.isAssignableFrom(model.getType()))
+                } else if (BuiltinSchemaTypeSystem.ST_IDREF.isAssignableFrom(model.getType())) {
                     warningType = BuiltinSchemaTypeSystem.ST_IDREF.getName().getLocalPart();
-                else if (BuiltinSchemaTypeSystem.ST_IDREFS.isAssignableFrom(model.getType()))
+                } else if (BuiltinSchemaTypeSystem.ST_IDREFS.isAssignableFrom(model.getType())) {
                     warningType = BuiltinSchemaTypeSystem.ST_IDREFS.getName().getLocalPart();
-                else if (BuiltinSchemaTypeSystem.ST_ENTITY.isAssignableFrom(model.getType()))
+                } else if (BuiltinSchemaTypeSystem.ST_ENTITY.isAssignableFrom(model.getType())) {
                     warningType = BuiltinSchemaTypeSystem.ST_ENTITY.getName().getLocalPart();
-                else if (BuiltinSchemaTypeSystem.ST_ENTITIES.isAssignableFrom(model.getType()))
+                } else if (BuiltinSchemaTypeSystem.ST_ENTITIES.isAssignableFrom(model.getType())) {
                     warningType = BuiltinSchemaTypeSystem.ST_ENTITIES.getName().getLocalPart();
-                else if (BuiltinSchemaTypeSystem.ST_NOTATION.isAssignableFrom(model.getType()))
-                {
-                    if (model.getType().getBuiltinTypeCode() == SchemaType.BTC_NOTATION)
-                    {
+                } else if (BuiltinSchemaTypeSystem.ST_NOTATION.isAssignableFrom(model.getType())) {
+                    if (model.getType().getBuiltinTypeCode() == SchemaType.BTC_NOTATION) {
                         StscState.get().recover(XmlErrorCodes.ELEM_NOTATION_TYPE_FORBIDDEN,
-                            new Object[]{ QNameHelper.pretty(model.getName()) },
+                            new Object[]{QNameHelper.pretty(model.getName())},
                             ((SchemaLocalElementImpl) model)._parseObject == null ? location :
-                            ((SchemaLocalElementImpl) model)._parseObject.selectAttribute("", "type"));
-                    }
-                    else
-                    {
-                        if (model.getType().getSimpleVariety() == SchemaType.UNION)
-                        {
+                                ((SchemaLocalElementImpl) model)._parseObject.selectAttribute("", "type"));
+                    } else {
+                        if (model.getType().getSimpleVariety() == SchemaType.UNION) {
                             SchemaType[] members = model.getType().getUnionConstituentTypes();
-                            for (int i = 0; i < members.length; i++)
-                                if (members[i].getBuiltinTypeCode() == SchemaType.BTC_NOTATION)
+                            for (int i = 0; i < members.length; i++) {
+                                if (members[i].getBuiltinTypeCode() == SchemaType.BTC_NOTATION) {
                                     StscState.get().recover(XmlErrorCodes.ELEM_NOTATION_TYPE_FORBIDDEN,
-                                        new Object[]{ QNameHelper.pretty(model.getName()) },
+                                        new Object[]{QNameHelper.pretty(model.getName())},
                                         ((SchemaLocalElementImpl) model)._parseObject == null ? location :
-                                        ((SchemaLocalElementImpl) model)._parseObject.selectAttribute("", "type"));
+                                            ((SchemaLocalElementImpl) model)._parseObject.selectAttribute("", "type"));
+                                }
+                            }
                         }
                         warningType = BuiltinSchemaTypeSystem.ST_NOTATION.getName().getLocalPart();
                     }
@@ -331,195 +274,185 @@
                     // Check that the Schema in which this is present doesn't have a targetNS
                     boolean hasNS;
                     SchemaType t = parentType;
-                    while (t.getOuterType() != null)
+                    while (t.getOuterType() != null) {
                         t = t.getOuterType();
-                    if (t.isDocumentType())
+                    }
+                    if (t.isDocumentType()) {
                         hasNS = t.getDocumentElementName().getNamespaceURI().length() > 0;
-                    else
+                    } else {
                         hasNS = t.getName().getNamespaceURI().length() > 0;
-                    if (hasNS)
+                    }
+                    if (hasNS) {
                         StscState.get().warning(XmlErrorCodes.ELEM_COMPATIBILITY_TARGETNS,
-                            new Object[] {QNameHelper.pretty(model.getName()) },
+                            new Object[]{QNameHelper.pretty(model.getName())},
                             ((SchemaLocalElementImpl) model)._parseObject == null ? location :
-                            ((SchemaLocalElementImpl) model)._parseObject);
+                                ((SchemaLocalElementImpl) model)._parseObject);
+                    }
                 }
 
-                if (warningType != null)
+                if (warningType != null) {
                     StscState.get().warning(XmlErrorCodes.ELEM_COMPATIBILITY_TYPE, new Object[]
-                        { QNameHelper.pretty(model.getName()), warningType },
+                            {QNameHelper.pretty(model.getName()), warningType},
                         ((SchemaLocalElementImpl) model)._parseObject == null ? location :
-                        ((SchemaLocalElementImpl) model)._parseObject.selectAttribute("", "type"));
+                            ((SchemaLocalElementImpl) model)._parseObject.selectAttribute("", "type"));
+                }
 
                 break;
 
-           default:
+            default:
                 // nothing to do.
                 break;
         }
     }
-    
+
     /**
      * The following code only checks rule #5 of http://www.w3.org/TR/xmlschema-1/#derivation-ok-restriction
-     *  (Everything else can and should be done in StscResolver, because we can give more detailed line # info there
+     * (Everything else can and should be done in StscResolver, because we can give more detailed line # info there
      */
-    public static boolean checkRestriction(SchemaTypeImpl sType)
-    {
-        if (sType.getDerivationType() == SchemaType.DT_RESTRICTION && !sType.isSimpleType())
-        {
+    public static boolean checkRestriction(SchemaTypeImpl sType) {
+        if (sType.getDerivationType() == SchemaType.DT_RESTRICTION && !sType.isSimpleType()) {
             StscState state = StscState.get();
-            
+
             // we don't remember very precise line number information, but it's better than nothin.
             XmlObject location = sType.getParseObject();
-        
+
             SchemaType baseType = sType.getBaseType();
-            if (baseType.isSimpleType())
-            {
+            if (baseType.isSimpleType()) {
                 state.error(XmlErrorCodes.SCHEMA_COMPLEX_TYPE$COMPLEX_CONTENT,
-                    new Object[] { QNameHelper.pretty(baseType.getName()) },
+                    new Object[]{QNameHelper.pretty(baseType.getName())},
                     location);
                 return false;
             }
-            
+
             // 5 The appropriate case among the following must be true:
-            switch (sType.getContentType())
-            {
+            switch (sType.getContentType()) {
                 case SchemaType.SIMPLE_CONTENT:
                     // 5.1 If the {content type} of the complex type definition is a simple type definition, then one of the following must be true:
-                    switch (baseType.getContentType())
-                    {
+                    switch (baseType.getContentType()) {
                         case SchemaType.SIMPLE_CONTENT:
                             // 5.1.1 The {content type} of the {base type definition} must be a simple type definition of which the {content type} is a �valid restriction� as defined in Derivation Valid (Restriction, Simple) (�3.14.6).
                             SchemaType cType = sType.getContentBasedOnType();
-                            if (cType != baseType)
-                            {
+                            if (cType != baseType) {
                                 // We have to check that the contentType is legally derived
                                 // from the base simple type in the hierarchy
                                 SchemaType bType = baseType;
-                                while (bType != null && !bType.isSimpleType())
+                                while (bType != null && !bType.isSimpleType()) {
                                     bType = bType.getContentBasedOnType();
-                                if (bType != null && !bType.isAssignableFrom(cType))
-                                {
+                                }
+                                if (bType != null && !bType.isAssignableFrom(cType)) {
                                     state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$SC_NOT_DERIVED,
                                         null, location);
                                     return false;
                                 }
                             }
                             break;
-                            
+
                         case SchemaType.MIXED_CONTENT:
                             // 5.1.2 The {base type definition} must be mixed and have a particle which is �emptiable� as defined in Particle Emptiable (�3.9.6).
-                            if (baseType.getContentModel() != null && !baseType.getContentModel().isSkippable())
-                            {
+                            if (baseType.getContentModel() != null && !baseType.getContentModel().isSkippable()) {
                                 state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$SC_AND_MIXED_EMPTIABLE,
                                     null, location);
                                 return false;
                             }
                             break;
-                            
+
                         default:
                             state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$SC_AND_SIMPLE_TYPE_OR_MIXED,
                                 null, location);
                             return false;
                     }
                     break;
-                    
+
                 case SchemaType.EMPTY_CONTENT:
                     // 5.2 If the {content type} of the complex type itself is empty , then one of the following must be true:
-                    switch (baseType.getContentType())
-                    {
+                    switch (baseType.getContentType()) {
                         case SchemaType.EMPTY_CONTENT:
                             // 5.2.1 The {content type} of the {base type definition} must also be empty.
                             break;
                         case SchemaType.MIXED_CONTENT:
                         case SchemaType.ELEMENT_CONTENT:
                             // 5.2.2 The {content type} of the {base type definition} must be elementOnly or mixed and have a particle which is �emptiable� as defined in Particle Emptiable (�3.9.6).
-                            if (baseType.getContentModel() != null && !baseType.getContentModel().isSkippable())
-                            {
+                            if (baseType.getContentModel() != null && !baseType.getContentModel().isSkippable()) {
                                 state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$EMPTY_AND_ELEMENT_OR_MIXED_EMPTIABLE,
                                     null, location);
                                 return false;
                             }
                             break;
-                        default:                            
+                        default:
                             state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$EMPTY_AND_NOT_SIMPLE,
                                 null, location);
                             return false;
                     }
                     break;
-                    
+
                 case SchemaType.MIXED_CONTENT:
                     // 5.3 If the {content type} of the {base type definition} is mixed...
-                    if (baseType.getContentType() != SchemaType.MIXED_CONTENT)
-                    {
+                    if (baseType.getContentType() != SchemaType.MIXED_CONTENT) {
                         state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$ELEMENT_OR_MIXED_AND_MIXED,
                             null, location);
                         return false;
                     }
-                    
+
                     // FALLTHROUGH
                 case SchemaType.ELEMENT_CONTENT:
                     // 5.3 ... or the {content type} of the complex type definition itself is element-only,...
-                    if (baseType.getContentType() == SchemaType.EMPTY_CONTENT)
-                    {
+                    if (baseType.getContentType() == SchemaType.EMPTY_CONTENT) {
                         state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$ELEMENT_OR_MIXED_AND_EMPTY,
                             null, location);
                         return false;
                     }
-                    if (baseType.getContentType() == SchemaType.SIMPLE_CONTENT)
-                    {
+                    if (baseType.getContentType() == SchemaType.SIMPLE_CONTENT) {
                         state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$ELEMENT_OR_MIXED_AND_SIMPLE,
                             null, location);
                         return false;
                     }
-                    
+
                     // 5.3 ... then the particle of the complex type definition itself must be a �valid restriction� of the particle of the {content type} of the {base type definition}
                     SchemaParticle baseModel = baseType.getContentModel();
                     SchemaParticle derivedModel = sType.getContentModel();
-                    
-                    if ( derivedModel == null && sType.getDerivationType()==SchemaType.DT_RESTRICTION )
-                    {
+
+                    if (derivedModel == null && sType.getDerivationType() == SchemaType.DT_RESTRICTION) {
                         // it is ok to have an empty contentModel if it's a restriction
                         // see Particle Valid (Restriction) (3.9.6) all three bulets 2.2.1
                         return true;
-                    }
-                    else if (baseModel == null || derivedModel == null)
-                    {
+                    } else if (baseModel == null || derivedModel == null) {
                         XBeanDebug.logStackTrace("Null models that weren't caught by EMPTY_CONTENT: " + baseType + " (" + baseModel + "), " + sType + " (" + derivedModel + ")");
                         state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$ELEMENT_OR_MIXED_AND_VALID, null, location);
                         return false;
                     }
-                    
+
                     // 5.3 ...  as defined in Particle Valid (Restriction) (�3.9.6).
-                    List errors = new ArrayList();
+                    List<XmlError> errors = new ArrayList<>();
                     boolean isValid = isParticleValidRestriction(baseModel, derivedModel, errors, location);
-                    if (!isValid)
-                    {
+                    if (!isValid) {
                         // we only add the last error, because isParticleValidRestriction may add errors
                         // to the collection that it later changes its mind about, or it may (inadvertently)
                         // forget to describe an error into the collection....
-                        if (errors.size() == 0)
+                        if (errors.size() == 0) {
                             state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$ELEMENT_OR_MIXED_AND_VALID, null, location);
-                        else
+                        } else {
                             state.getErrorListener().add(errors.get(errors.size() - 1));
-                            //state.getErrorListener().addAll(errors);
+                        }
+                        //state.getErrorListener().addAll(errors);
                         return false; // KHK: should return false, right?
                     }
             }
         }
         return true;
     }
-    
+
     /**
      * This function takes in two schema particle types, a baseModel, and a derived model and returns true if the
      * derivedModel can be egitimately be used for restriction.  Errors are put into the errors collections.
-     * @param baseModel - The base schema particle
+     *
+     * @param baseModel    - The base schema particle
      * @param derivedModel - The derived (restricted) schema particle
-     * @param errors - Invalid restriction errors are put into this collection
+     * @param errors       - Invalid restriction errors are put into this collection
      * @param context
      * @return boolean, true if valid restruction, false if invalid restriction
      * @
      */
-    public static boolean isParticleValidRestriction(SchemaParticle baseModel, SchemaParticle derivedModel, Collection errors, XmlObject context)  {
+    public static boolean isParticleValidRestriction(SchemaParticle baseModel, SchemaParticle derivedModel, Collection<XmlError> errors, XmlObject context) {
         boolean restrictionValid = false;
         // 1 They are the same particle.
         if (baseModel.equals(derivedModel)) {
@@ -538,7 +471,7 @@
                         case SchemaParticle.CHOICE:
                         case SchemaParticle.SEQUENCE:
                             errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION$INVALID_RESTRICTION,
-                                new Object[] { printParticle(derivedModel), printParticle(baseModel) }, context));
+                                new Object[]{printParticle(derivedModel), printParticle(baseModel)}, context));
                             restrictionValid = false;
                             break;
                         default:
@@ -574,7 +507,7 @@
                         case SchemaParticle.WILDCARD:
                         case SchemaParticle.CHOICE:
                             errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION$INVALID_RESTRICTION,
-                                new Object[] { printParticle(derivedModel), printParticle(baseModel) }, context));
+                                new Object[]{printParticle(derivedModel), printParticle(baseModel)}, context));
                             restrictionValid = false;
                             break;
                         case SchemaParticle.ALL:
@@ -595,7 +528,7 @@
                         case SchemaParticle.WILDCARD:
                         case SchemaParticle.ALL:
                             errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION$INVALID_RESTRICTION,
-                                new Object[] { printParticle(derivedModel), printParticle(baseModel) }, context));
+                                new Object[]{printParticle(derivedModel), printParticle(baseModel)}, context));
                             restrictionValid = false;
                             break;
                         case SchemaParticle.CHOICE:
@@ -617,7 +550,7 @@
                         case SchemaParticle.ALL:
                         case SchemaParticle.CHOICE:
                             errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION$INVALID_RESTRICTION,
-                                new Object[] { printParticle(derivedModel), printParticle(baseModel) }, context));
+                                new Object[]{printParticle(derivedModel), printParticle(baseModel)}, context));
                             restrictionValid = false;
                             break;
                         case SchemaParticle.SEQUENCE:
@@ -636,7 +569,7 @@
         return restrictionValid;
     }
 
-    private static boolean mapAndSum(SchemaParticle baseModel, SchemaParticle derivedModel, Collection errors, XmlObject context)  {
+    private static boolean mapAndSum(SchemaParticle baseModel, SchemaParticle derivedModel, Collection<XmlError> errors, XmlObject context) {
         // mapAndSum is call if base: CHOICE, derived: SEQUENCE
         assert baseModel.getParticleType() == SchemaParticle.CHOICE;
         assert derivedModel.getParticleType() == SchemaParticle.SEQUENCE;
@@ -675,7 +608,7 @@
             if (!foundMatch) {
                 mapAndSumValid = false;
                 errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_MAP_AND_SUM$MAP,
-                    new Object[] { printParticle(derivedParticle) },
+                    new Object[]{printParticle(derivedParticle)},
                     context));
                 // KHK: if we don't return false now, this error may get swallowed by an error produced below
                 return false;
@@ -704,26 +637,26 @@
         if (derivedRangeMin.compareTo(baseModel.getMinOccurs()) < 0) {
             mapAndSumValid = false;
             errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_MAP_AND_SUM$SUM_MIN_OCCURS_GTE_MIN_OCCURS,
-                new Object[] { derivedRangeMin.toString(), baseModel.getMinOccurs().toString() },
+                new Object[]{derivedRangeMin.toString(), baseModel.getMinOccurs().toString()},
                 context));
         } else if (baseModel.getMaxOccurs() != UNBOUNDED && (derivedRangeMax == UNBOUNDED || derivedRangeMax.compareTo(baseModel.getMaxOccurs()) > 0)) {
             mapAndSumValid = false;
             errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_MAP_AND_SUM$SUM_MAX_OCCURS_LTE_MAX_OCCURS,
-                    new Object[] { derivedRangeMax == UNBOUNDED ? "unbounded" : derivedRangeMax.toString(), baseModel.getMaxOccurs().toString() },
+                new Object[]{derivedRangeMax == UNBOUNDED ? "unbounded" : derivedRangeMax.toString(), baseModel.getMaxOccurs().toString()},
                 context));
         }
 
         return mapAndSumValid;
     }
 
-    private static boolean recurseAsIfGroup(SchemaParticle baseModel, SchemaParticle derivedModel, Collection errors, XmlObject context) {
+    private static boolean recurseAsIfGroup(SchemaParticle baseModel, SchemaParticle derivedModel, Collection<XmlError> errors, XmlObject context) {
         // recurseAsIfGroup is called if:
         // base: ALL, derived: ELEMENT
         // base: CHOICE, derived: ELEMENT
         // base: SEQUENCE, derived: ELEMENT
         assert (baseModel.getParticleType() == SchemaParticle.ALL && derivedModel.getParticleType() == SchemaParticle.ELEMENT)
-                || (baseModel.getParticleType() == SchemaParticle.CHOICE && derivedModel.getParticleType() == SchemaParticle.ELEMENT)
-                || (baseModel.getParticleType() == SchemaParticle.SEQUENCE && derivedModel.getParticleType() == SchemaParticle.ELEMENT);
+               || (baseModel.getParticleType() == SchemaParticle.CHOICE && derivedModel.getParticleType() == SchemaParticle.ELEMENT)
+               || (baseModel.getParticleType() == SchemaParticle.SEQUENCE && derivedModel.getParticleType() == SchemaParticle.ELEMENT);
         // Schema Component Constraint: Particle Derivation OK (Elt:All/Choice/Sequence -- RecurseAsIfGroup)
 
         // For an element declaration particle to be a �valid restriction� of a group particle
@@ -739,13 +672,13 @@
         asIfPart.setParticleType(baseModel.getParticleType());
         asIfPart.setMinOccurs(BigInteger.ONE);
         asIfPart.setMaxOccurs(BigInteger.ONE);
-        asIfPart.setParticleChildren(new SchemaParticle[] { derivedModel });
-        
+        asIfPart.setParticleChildren(new SchemaParticle[]{derivedModel});
+
         // the recurse
-        return isParticleValidRestriction(baseModel, asIfPart, errors, context); 
+        return isParticleValidRestriction(baseModel, asIfPart, errors, context);
     }
 
-    private static boolean recurseLax(SchemaParticle baseModel, SchemaParticle derivedModel, Collection errors, XmlObject context)  {
+    private static boolean recurseLax(SchemaParticle baseModel, SchemaParticle derivedModel, Collection<XmlError> errors, XmlObject context) {
         // recurseLax is called if base: CHOICE, derived: CHOICE
         assert baseModel.getParticleType() == SchemaParticle.CHOICE && derivedModel.getParticleType() == SchemaParticle.CHOICE;
         boolean recurseLaxValid = true;
@@ -773,7 +706,7 @@
         SchemaParticle[] derivedParticleArray = derivedModel.getParticleChildren();
         SchemaParticle[] baseParticleArray = baseModel.getParticleChildren();
         int i = 0, j = 0;
-        for (; i < derivedParticleArray.length && j < baseParticleArray.length;) {
+        for (; i < derivedParticleArray.length && j < baseParticleArray.length; ) {
             SchemaParticle derivedParticle = derivedParticleArray[i];
             SchemaParticle baseParticle = baseParticleArray[j];
             // try to match the two particles by recursing
@@ -796,7 +729,7 @@
             //String message = "Found derived particles that are not matched in the base content model.";
             //errors.add(XmlError.forObject(formatDerivedMappingError(message, baseModel, derivedModel), context));
             errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_RECURSE_LAX$MAP,
-                new Object[] { printParticles(baseParticleArray, i) },
+                new Object[]{printParticles(baseParticleArray, i)},
                 context));
         }
 
@@ -804,7 +737,7 @@
         return recurseLaxValid;
     }
 
-    private static boolean recurseUnordered(SchemaParticle baseModel, SchemaParticle derivedModel, Collection errors, XmlObject context) {
+    private static boolean recurseUnordered(SchemaParticle baseModel, SchemaParticle derivedModel, Collection<XmlError> errors, XmlObject context) {
         // recurseUnorder is called when base: ALL and derived: SEQ
         assert baseModel.getParticleType() == SchemaParticle.ALL && derivedModel.getParticleType() == SchemaParticle.SEQUENCE;
         boolean recurseUnorderedValid = true;
@@ -834,9 +767,10 @@
         HashMap baseParticleMap = new HashMap(10);
         Object MAPPED = new Object();
         // Initialize the hashmap
-        for (int i = 0; i < baseParticles.length; i++)
+        for (int i = 0; i < baseParticles.length; i++) {
             baseParticleMap.put(baseParticles[i].getName(), baseParticles[i]);
-        
+        }
+
         // go thru the sequence (derived model's children) and check off from base particle map
         SchemaParticle[] derivedParticles = derivedModel.getParticleChildren();
         for (int i = 0; i < derivedParticles.length; i++) {
@@ -844,7 +778,7 @@
             if (baseParticle == null) {
                 recurseUnorderedValid = false;
                 errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_RECURSE_UNORDERED$MAP,
-                    new Object[] { printParticle(derivedParticles[i]) }, context ));
+                    new Object[]{printParticle(derivedParticles[i])}, context));
                 break;
             } else {
                 // got a match
@@ -852,21 +786,20 @@
                     // whoa, this base particle has already been matched (see 2.1 above)
                     recurseUnorderedValid = false;
                     errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_RECURSE_UNORDERED$MAP_UNIQUE,
-                        new Object[] { printParticle(derivedParticles[i]) }, context ));
+                        new Object[]{printParticle(derivedParticles[i])}, context));
                     break;
                 } else {
-                    SchemaParticle matchedBaseParticle = (SchemaParticle)baseParticle;
+                    SchemaParticle matchedBaseParticle = (SchemaParticle) baseParticle;
                     if (derivedParticles[i].getMaxOccurs() == null ||
-                            derivedParticles[i].getMaxOccurs().compareTo(BigInteger.ONE) > 0) {
+                        derivedParticles[i].getMaxOccurs().compareTo(BigInteger.ONE) > 0) {
                         // no derived particles can have a max occurs greater than 1
                         recurseUnorderedValid = false;
                         errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_RECURSE_UNORDERED$MAP_MAX_OCCURS_1,
-                            new Object[] { printParticle(derivedParticles[i]), printMaxOccurs(derivedParticles[i].getMinOccurs()) },
+                            new Object[]{printParticle(derivedParticles[i]), printMaxOccurs(derivedParticles[i].getMinOccurs())},
                             context));
                         break;
                     }
-                    if (!isParticleValidRestriction(matchedBaseParticle, derivedParticles[i], errors, context))
-                    {
+                    if (!isParticleValidRestriction(matchedBaseParticle, derivedParticles[i], errors, context)) {
                         // already have an error
                         recurseUnorderedValid = false;
                         break;
@@ -881,13 +814,13 @@
         if (recurseUnorderedValid) {
             // get all the hashmap keys and loop thru looking for NOT_MAPPED
             Set baseParticleCollection = baseParticleMap.keySet();
-            for (Iterator iterator = baseParticleCollection.iterator(); iterator.hasNext();) {
+            for (Iterator iterator = baseParticleCollection.iterator(); iterator.hasNext(); ) {
                 QName baseParticleQName = (QName) iterator.next();
-                if (baseParticleMap.get(baseParticleQName) != MAPPED && !((SchemaParticle)baseParticleMap.get(baseParticleQName)).isSkippable()) {
+                if (baseParticleMap.get(baseParticleQName) != MAPPED && !((SchemaParticle) baseParticleMap.get(baseParticleQName)).isSkippable()) {
                     // this base particle was not mapped and is not "particle emptiable" (skippable)
                     recurseUnorderedValid = false;
                     errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_RECURSE_UNORDERED$UNMAPPED_ARE_EMPTIABLE,
-                        new Object[] { printParticle((SchemaParticle)baseParticleMap.get(baseParticleQName)) },
+                        new Object[]{printParticle((SchemaParticle) baseParticleMap.get(baseParticleQName))},
                         context));
                 }
             }
@@ -896,7 +829,7 @@
         return recurseUnorderedValid;
     }
 
-    private static boolean recurse(SchemaParticle baseModel, SchemaParticle derivedModel, Collection errors, XmlObject context) {
+    private static boolean recurse(SchemaParticle baseModel, SchemaParticle derivedModel, Collection<XmlError> errors, XmlObject context) {
         // recurse is called when base: ALL derived: ALL or base: SEQUENCE derived: SEQUENCE
         boolean recurseValid = true;
         // For an all or sequence group particle to be a �valid restriction� of another group particle with the same
@@ -930,7 +863,7 @@
         SchemaParticle[] derivedParticleArray = derivedModel.getParticleChildren();
         SchemaParticle[] baseParticleArray = baseModel.getParticleChildren();
         int i = 0, j = 0;
-        for (; i < derivedParticleArray.length && j < baseParticleArray.length;) {
+        for (; i < derivedParticleArray.length && j < baseParticleArray.length; ) {
             SchemaParticle derivedParticle = derivedParticleArray[i];
             SchemaParticle baseParticle = baseParticleArray[j];
             // try to match the two particles by recursing
@@ -948,8 +881,8 @@
                     // whoa, particles are not valid restrictions and base is not skippable - ERROR
                     recurseValid = false;
                     errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_RECURSE$MAP_VALID,
-                        new Object[] { printParticle(derivedParticle), printParticle(derivedModel), 
-                                       printParticle(baseParticle), printParticle(baseModel) },
+                        new Object[]{printParticle(derivedParticle), printParticle(derivedModel),
+                            printParticle(baseParticle), printParticle(baseModel)},
                         context));
                     break;
                 }
@@ -962,7 +895,7 @@
         if (i < derivedParticleArray.length) {
             recurseValid = false;
             errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_RECURSE$MAP,
-                new Object[] { printParticle(derivedModel), printParticle(baseModel), printParticles(derivedParticleArray, i) },
+                new Object[]{printParticle(derivedModel), printParticle(baseModel), printParticles(derivedParticleArray, i)},
                 context));
         } else {
             // if at end of derived particle array and not at end of base particle array then chck remaining
@@ -974,11 +907,10 @@
                         particles.add(baseParticleArray[k]);
                     }
                 }
-                if (particles.size() > 0)
-                {
+                if (particles.size() > 0) {
                     recurseValid = false;
                     errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_RECURSE$UNMAPPED_ARE_EMPTIABLE,
-                        new Object[] { printParticle(baseModel), printParticle(derivedModel), printParticles(particles)}, context));
+                        new Object[]{printParticle(baseModel), printParticle(derivedModel), printParticles(particles)}, context));
                 }
             }
         }
@@ -986,22 +918,22 @@
         return recurseValid;
     }
 
-    private static boolean nsRecurseCheckCardinality(SchemaParticle baseModel, SchemaParticle derivedModel, Collection errors, XmlObject context) {
+    private static boolean nsRecurseCheckCardinality(SchemaParticle baseModel, SchemaParticle derivedModel, Collection<XmlError> errors, XmlObject context) {
         // nsRecurseCheckCardinality is called when:
         // base: ANY, derived: ALL
         // base: ANY, derived: CHOICE
         // base: ANY, derived: SEQUENCE
         assert baseModel.getParticleType() == SchemaParticle.WILDCARD;
         assert (derivedModel.getParticleType() == SchemaParticle.ALL)
-                || (derivedModel.getParticleType() == SchemaParticle.CHOICE)
-                || (derivedModel.getParticleType() == SchemaParticle.SEQUENCE);
+               || (derivedModel.getParticleType() == SchemaParticle.CHOICE)
+               || (derivedModel.getParticleType() == SchemaParticle.SEQUENCE);
         boolean nsRecurseCheckCardinality = true;
         // For a group particle to be a �valid restriction� of a wildcard particle all of the following must be true:
         // 1 Every member of the {particles} of the group is a �valid restriction� of the wildcard as defined by Particle Valid (Restriction) (�3.9.6).
         //  Note:  not positive what this means.  Interpreting to mean that every particle of the group must adhere to wildcard derivation rules
         //         in a recursive manner
         //  Loop thru the children particles of the group and invoke the appropriate function to check for wildcard restriction validity
-        
+
         // BAU - an errata should be submitted on this clause of the spec, because the
         // spec makes no sense, as the xstc particlesR013.xsd test exemplifies.
         // what we _should_ so is an "as if" on the wildcard, allowing it minOccurs="0" maxOccurs="unbounded"
@@ -1051,7 +983,7 @@
         return nsRecurseCheckCardinality;
     }
 
-    private static boolean checkGroupOccurrenceOK(SchemaParticle baseModel, SchemaParticle derivedModel, Collection errors, XmlObject context) {
+    private static boolean checkGroupOccurrenceOK(SchemaParticle baseModel, SchemaParticle derivedModel, Collection<XmlError> errors, XmlObject context) {
         boolean groupOccurrenceOK = true;
         BigInteger minRange = BigInteger.ZERO;
         BigInteger maxRange = BigInteger.ZERO;
@@ -1072,7 +1004,7 @@
         if (minRange.compareTo(baseModel.getMinOccurs()) < 0) {
             groupOccurrenceOK = false;
             errors.add(XmlError.forObject(XmlErrorCodes.OCCURRENCE_RANGE$MIN_GTE_MIN,
-                new Object[] { printParticle(derivedModel), printParticle(baseModel) },
+                new Object[]{printParticle(derivedModel), printParticle(baseModel)},
                 context));
         }
         // Check max occurs for validity
@@ -1084,20 +1016,20 @@
             if (maxRange == UNBOUNDED) {
                 groupOccurrenceOK = false;
                 errors.add(XmlError.forObject(XmlErrorCodes.OCCURRENCE_RANGE$MAX_LTE_MAX,
-                    new Object[] { printParticle(derivedModel), printParticle(baseModel) },
+                    new Object[]{printParticle(derivedModel), printParticle(baseModel)},
                     context));
             } else {
                 if (maxRange.compareTo(baseModel.getMaxOccurs()) > 0) {
                     groupOccurrenceOK = false;
                     errors.add(XmlError.forObject(XmlErrorCodes.OCCURRENCE_RANGE$MAX_LTE_MAX,
-                        new Object[] { printParticle(derivedModel), printParticle(baseModel) },
+                        new Object[]{printParticle(derivedModel), printParticle(baseModel)},
                         context));
                 }
             }
         }
         return groupOccurrenceOK;
     }
-    
+
     private static BigInteger getEffectiveMaxRangeChoice(SchemaParticle derivedModel) {
         BigInteger maxRange = BigInteger.ZERO;
         BigInteger UNBOUNDED = null;
@@ -1270,8 +1202,9 @@
         // declaration particle in the group's {particles} and the minimum part of the effective total range of each of
         // the group particles in the group's {particles} (or 0 if there are no {particles}).
         SchemaParticle[] particleChildren = derivedModel.getParticleChildren();
-        if (particleChildren.length == 0)
+        if (particleChildren.length == 0) {
             return BigInteger.ZERO;
+        }
         BigInteger minRange = null;
         // get the minimum of every wildcard or element
         // total up the effective total range for each group
@@ -1299,8 +1232,9 @@
                     break;
             }
         }
-        if (minRange == null)
+        if (minRange == null) {
             minRange = BigInteger.ZERO;
+        }
 
         // calculate the total
         minRange = derivedModel.getMinOccurs().multiply(minRange);
@@ -1342,7 +1276,7 @@
         return minRange;
     }
 
-    private static boolean nsSubset(SchemaParticle baseModel, SchemaParticle derivedModel, Collection errors, XmlObject context) {
+    private static boolean nsSubset(SchemaParticle baseModel, SchemaParticle derivedModel, Collection<XmlError> errors, XmlObject context) {
         // nsSubset is called when base: ANY, derived: ANY
         assert baseModel.getParticleType() == SchemaParticle.WILDCARD;
         assert derivedModel.getParticleType() == SchemaParticle.WILDCARD;
@@ -1357,7 +1291,7 @@
             } else {
                 nsSubset = false;
                 errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_NS_SUBST$WILDCARD_SUBSET,
-                    new Object[] { printParticle(derivedModel), printParticle(baseModel) }, context));
+                    new Object[]{printParticle(derivedModel), printParticle(baseModel)}, context));
             }
         } else {
             nsSubset = false;
@@ -1369,7 +1303,7 @@
         return nsSubset;
     }
 
-    private static boolean nsCompat(SchemaParticle baseModel, SchemaLocalElement derivedElement, Collection errors, XmlObject context) {
+    private static boolean nsCompat(SchemaParticle baseModel, SchemaLocalElement derivedElement, Collection<XmlError> errors, XmlObject context) {
         // nsCompat is called when base: ANY, derived: ELEMENT
         assert baseModel.getParticleType() == SchemaParticle.WILDCARD;
         boolean nsCompat = false;
@@ -1387,7 +1321,7 @@
         } else {
             nsCompat = false;
             errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_NS_COMPAT$WILDCARD_VALID,
-                new Object[] { printParticle((SchemaParticle)derivedElement), printParticle(baseModel) },
+                new Object[]{printParticle((SchemaParticle) derivedElement), printParticle(baseModel)},
                 context));
         }
 
@@ -1395,90 +1329,82 @@
         return nsCompat;
     }
 
-    private static boolean nameAndTypeOK(SchemaLocalElement baseElement, SchemaLocalElement derivedElement, Collection errors, XmlObject context) {
+    private static boolean nameAndTypeOK(SchemaLocalElement baseElement, SchemaLocalElement derivedElement, Collection<XmlError> errors, XmlObject context) {
         // nameAndTypeOK called when base: ELEMENT and derived: ELEMENT
-        
+
         // Schema Component Constraint: Particle Restriction OK (Elt:Elt -- NameAndTypeOK)
         // 1 The declarations' {name}s and {target namespace}s are the same.
-        if (!((SchemaParticle)baseElement).canStartWithElement(derivedElement.getName())) {
+        if (!((SchemaParticle) baseElement).canStartWithElement(derivedElement.getName())) {
             errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION_NAME_AND_TYPE$NAME,
-                new Object[] { printParticle((SchemaParticle)derivedElement), printParticle((SchemaParticle)baseElement) }, context));
+                new Object[]{printParticle((SchemaParticle) derivedElement), printParticle((SchemaParticle) baseElement)}, context));
             return false;
         }
-        
+
         // 2 Either B's {nillable} is true or R's {nillable} is false.
         if (!baseElement.isNillable() && derivedElement.isNillable()) {
             errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION_NAME_AND_TYPE$NILLABLE,
-                new Object[] { printParticle((SchemaParticle)derivedElement), printParticle((SchemaParticle)baseElement) }, context));
+                new Object[]{printParticle((SchemaParticle) derivedElement), printParticle((SchemaParticle) baseElement)}, context));
             return false;
         }
-        
+
         // 3 R's occurrence range is a valid restriction of B's occurrence range as defined by Occurrence Range OK (�3.9.6).
         if (!occurrenceRangeOK((SchemaParticle) baseElement, (SchemaParticle) derivedElement, errors, context)) {
             // error already produced
             return false;
         }
-        
+
         // 4 either B's declaration's {value constraint} is absent, or is not fixed,
         // or R's declaration's {value constraint} is fixed with the same value.
-        if (!checkFixed(baseElement, derivedElement, errors, context))
-        {
+        if (!checkFixed(baseElement, derivedElement, errors, context)) {
             // error already produced
             return false;
         }
-        
+
         // 5 R's declaration's {identity-constraint definitions} is a subset of B's declaration's {identity-constraint definitions}, if any.
-        if (!checkIdentityConstraints(baseElement, derivedElement, errors, context))
-        {
+        if (!checkIdentityConstraints(baseElement, derivedElement, errors, context)) {
             // error already produced
             return false;
         }
-        
+
         // 7 R's {type definition} is validly derived given {extension, list, union} from B's {type definition} as
         // defined by Type Derivation OK (Complex) (�3.4.6) or Type Derivation OK (Simple) (�3.14.6), as appropriate.
-        if (!typeDerivationOK(baseElement.getType(), derivedElement.getType(), errors, context))
-        {
+        if (!typeDerivationOK(baseElement.getType(), derivedElement.getType(), errors, context)) {
             // error already produced
             return false;
         }
-        
+
         // 6 R's declaration's {disallowed substitutions} is a superset of B's declaration's {disallowed substitutions}.
-        if (!blockSetOK(baseElement, derivedElement, errors, context))
-        {
+        if (!blockSetOK(baseElement, derivedElement, errors, context)) {
             // error already produced
-            return false;    
+            return false;
         }
 
         return true;
     }
-    
-    private static boolean blockSetOK(SchemaLocalElement baseElement, SchemaLocalElement derivedElement, Collection errors, XmlObject context)
-    {
-        if (baseElement.blockRestriction() && !derivedElement.blockRestriction())
-        {
+
+    private static boolean blockSetOK(SchemaLocalElement baseElement, SchemaLocalElement derivedElement, Collection<XmlError> errors, XmlObject context) {
+        if (baseElement.blockRestriction() && !derivedElement.blockRestriction()) {
             errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION_NAME_AND_TYPE$DISALLOWED_SUBSTITUTIONS,
-                new Object[] { printParticle((SchemaParticle)derivedElement), "restriction", printParticle((SchemaParticle)baseElement) },
+                new Object[]{printParticle((SchemaParticle) derivedElement), "restriction", printParticle((SchemaParticle) baseElement)},
                 context));
             return false;
         }
-        if (baseElement.blockExtension() && !derivedElement.blockExtension())
-        {
+        if (baseElement.blockExtension() && !derivedElement.blockExtension()) {
             errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION_NAME_AND_TYPE$DISALLOWED_SUBSTITUTIONS,
-                new Object[] { printParticle((SchemaParticle)derivedElement), "extension", printParticle((SchemaParticle)baseElement) },
+                new Object[]{printParticle((SchemaParticle) derivedElement), "extension", printParticle((SchemaParticle) baseElement)},
                 context));
             return false;
         }
-        if (baseElement.blockSubstitution() && !derivedElement.blockSubstitution())
-        {
+        if (baseElement.blockSubstitution() && !derivedElement.blockSubstitution()) {
             errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION_NAME_AND_TYPE$DISALLOWED_SUBSTITUTIONS,
-                new Object[] { printParticle((SchemaParticle)derivedElement), "substitution", printParticle((SchemaParticle)baseElement) },
+                new Object[]{printParticle((SchemaParticle) derivedElement), "substitution", printParticle((SchemaParticle) baseElement)},
                 context));
             return false;
         }
-        return true;    
+        return true;
     }
 
-    private static boolean typeDerivationOK(SchemaType baseType, SchemaType derivedType, Collection errors, XmlObject context){
+    private static boolean typeDerivationOK(SchemaType baseType, SchemaType derivedType, Collection<XmlError> errors, XmlObject context) {
         boolean typeDerivationOK = false;
         // 1 If B and D are not the same type definition, then the {derivation method} of D must not be in the subset.
         // 2 One of the following must be true:
@@ -1498,38 +1424,39 @@
             // derived type is not a sub-type of base type
             typeDerivationOK = false;
             errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION_NAME_AND_TYPE$TYPE_VALID,
-                new Object[] { printType(derivedType), printType(baseType) }, context));
+                new Object[]{printType(derivedType), printType(baseType)}, context));
         }
 
         return typeDerivationOK;
     }
 
-    private static boolean checkAllDerivationsForRestriction(SchemaType baseType, SchemaType derivedType, Collection errors, XmlObject context) {
+    private static boolean checkAllDerivationsForRestriction(SchemaType baseType, SchemaType derivedType, Collection<XmlError> errors, XmlObject context) {
         boolean allDerivationsAreRestrictions = true;
         SchemaType currentType = derivedType;
 
         // XMLBEANS-66: if baseType is a union, check restriction is of one of the constituant types
         Set possibleTypes = null;
-        if (baseType.getSimpleVariety() == SchemaType.UNION)
+        if (baseType.getSimpleVariety() == SchemaType.UNION) {
             possibleTypes = new HashSet(Arrays.asList(baseType.getUnionConstituentTypes()));
+        }
 
         // run up the types hierarchy from derived Type to base Type and make sure that all are derived by
         //   restriction.  If any are not then this is not a valid restriction.
         while (!baseType.equals(currentType) &&
-            possibleTypes != null && !possibleTypes.contains(currentType)) {
+               possibleTypes != null && !possibleTypes.contains(currentType)) {
             if (currentType.getDerivationType() == SchemaType.DT_RESTRICTION) {
                 currentType = currentType.getBaseType();
             } else {
                 allDerivationsAreRestrictions = false;
                 errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION_NAME_AND_TYPE$TYPE_RESTRICTED,
-                    new Object[] { printType(derivedType), printType(baseType), printType(currentType) }, context));
+                    new Object[]{printType(derivedType), printType(baseType), printType(currentType)}, context));
                 break;
             }
         }
         return allDerivationsAreRestrictions;
     }
 
-    private static boolean checkIdentityConstraints(SchemaLocalElement baseElement, SchemaLocalElement derivedElement, Collection errors, XmlObject context) {
+    private static boolean checkIdentityConstraints(SchemaLocalElement baseElement, SchemaLocalElement derivedElement, Collection<XmlError> errors, XmlObject context) {
         // 5 R's declaration's {identity-constraint definitions} is a subset of B's declaration's {identity-constraint definitions}, if any.
         boolean identityConstraintsOK = true;
 
@@ -1541,7 +1468,7 @@
             if (checkForIdentityConstraintExistence(baseConstraints, derivedConstraint)) {
                 identityConstraintsOK = false;
                 errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION_NAME_AND_TYPE$IDENTITY_CONSTRAINTS,
-                    new Object[] { printParticle((SchemaParticle)derivedElement), printParticle((SchemaParticle)baseElement) },
+                    new Object[]{printParticle((SchemaParticle) derivedElement), printParticle((SchemaParticle) baseElement)},
                     context));
                 break;
             }
@@ -1563,7 +1490,7 @@
     }
 
 
-    private static boolean checkFixed(SchemaLocalElement baseModel, SchemaLocalElement derivedModel, Collection errors, XmlObject context) {
+    private static boolean checkFixed(SchemaLocalElement baseModel, SchemaLocalElement derivedModel, Collection<XmlError> errors, XmlObject context) {
         // 4 either B's declaration's {value constraint} is absent, or is not fixed,
         // or R's declaration's {value constraint} is fixed with the same value.
         boolean checkFixed = false;
@@ -1574,8 +1501,8 @@
             } else {
                 // The derived element has a fixed value that is different than the base element
                 errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION_NAME_AND_TYPE$FIXED,
-                    new Object[] { printParticle((SchemaParticle)derivedModel), derivedModel.getDefaultText(),
-                                   printParticle((SchemaParticle)baseModel), baseModel.getDefaultText() },
+                    new Object[]{printParticle((SchemaParticle) derivedModel), derivedModel.getDefaultText(),
+                        printParticle((SchemaParticle) baseModel), baseModel.getDefaultText()},
                     context));
                 checkFixed = false;
             }
@@ -1586,7 +1513,7 @@
         return checkFixed;
     }
 
-    private static boolean occurrenceRangeOK(SchemaParticle baseParticle, SchemaParticle derivedParticle, Collection errors, XmlObject context) {
+    private static boolean occurrenceRangeOK(SchemaParticle baseParticle, SchemaParticle derivedParticle, Collection<XmlError> errors, XmlObject context) {
         boolean occurrenceRangeOK = false;
         // Note: in the following comments (from the schema spec) other is the baseModel
         // 1 Its {min occurs} is greater than or equal to the other's {min occurs}.
@@ -1598,55 +1525,50 @@
             } else {
                 // 2.2 Both {max occurs} are numbers, and the particle's is less than or equal to the other's.
                 if (derivedParticle.getMaxOccurs() != null && baseParticle.getMaxOccurs() != null &&
-                        derivedParticle.getMaxOccurs().compareTo(baseParticle.getMaxOccurs()) <= 0) {
+                    derivedParticle.getMaxOccurs().compareTo(baseParticle.getMaxOccurs()) <= 0) {
                     occurrenceRangeOK = true;
                 } else {
                     occurrenceRangeOK = false;
                     errors.add(XmlError.forObject(XmlErrorCodes.OCCURRENCE_RANGE$MAX_LTE_MAX,
-                        new Object[] { printParticle(derivedParticle), printMaxOccurs(derivedParticle.getMaxOccurs()),
-                                       printParticle(baseParticle), printMaxOccurs(baseParticle.getMaxOccurs()) },
+                        new Object[]{printParticle(derivedParticle), printMaxOccurs(derivedParticle.getMaxOccurs()),
+                            printParticle(baseParticle), printMaxOccurs(baseParticle.getMaxOccurs())},
                         context));
                 }
             }
         } else {
             occurrenceRangeOK = false;
             errors.add(XmlError.forObject(XmlErrorCodes.OCCURRENCE_RANGE$MIN_GTE_MIN,
-                new Object[] { printParticle(derivedParticle), derivedParticle.getMinOccurs().toString(),
-                               printParticle(baseParticle), baseParticle.getMinOccurs().toString() },
+                new Object[]{printParticle(derivedParticle), derivedParticle.getMinOccurs().toString(),
+                    printParticle(baseParticle), baseParticle.getMinOccurs().toString()},
                 context));
         }
         return occurrenceRangeOK;
     }
 
-    private static String printParticles(List parts)
-    {
-        return printParticles((SchemaParticle[])parts.toArray(new SchemaParticle[parts.size()]));
+    private static String printParticles(List parts) {
+        return printParticles((SchemaParticle[]) parts.toArray(new SchemaParticle[parts.size()]));
     }
-    
-    private static String printParticles(SchemaParticle[] parts)
-    {
+
+    private static String printParticles(SchemaParticle[] parts) {
         return printParticles(parts, 0, parts.length);
     }
-    
-    private static String printParticles(SchemaParticle[] parts, int start)
-    {
+
+    private static String printParticles(SchemaParticle[] parts, int start) {
         return printParticles(parts, start, parts.length);
     }
-    
-    private static String printParticles(SchemaParticle[] parts, int start, int end)
-    {
+
+    private static String printParticles(SchemaParticle[] parts, int start, int end) {
         StringBuilder buf = new StringBuilder(parts.length * 30);
-        for (int i = start; i < end; )
-        {
+        for (int i = start; i < end; ) {
             buf.append(printParticle(parts[i]));
-            if (++i != end)
+            if (++i != end) {
                 buf.append(", ");
+            }
         }
         return buf.toString();
     }
-    
-    private static String printParticle(SchemaParticle part)
-    {
+
+    private static String printParticle(SchemaParticle part) {
         switch (part.getParticleType()) {
             case SchemaParticle.ALL:
                 return "<all>";
@@ -1658,71 +1580,60 @@
                 return "<sequence>";
             case SchemaParticle.WILDCARD:
                 return "<any>";
-            default :
+            default:
                 return "??";
         }
     }
-    
-    private static String printMaxOccurs(BigInteger bi)
-    {
-        if (bi == null)
+
+    private static String printMaxOccurs(BigInteger bi) {
+        if (bi == null) {
             return "unbounded";
+        }
         return bi.toString();
     }
-    
-    private static String printType(SchemaType type)
-    {
-        if (type.getName() != null)
+
+    private static String printType(SchemaType type) {
+        if (type.getName() != null) {
             return QNameHelper.pretty(type.getName());
+        }
         return type.toString();
     }
 
-    private static void checkSubstitutionGroups(SchemaGlobalElement[] elts)
-    {
+    private static void checkSubstitutionGroups(SchemaGlobalElement[] elts) {
         StscState state = StscState.get();
 
-        for (int i = 0 ; i < elts.length ; i++)
-        {
+        for (int i = 0; i < elts.length; i++) {
             SchemaGlobalElement elt = elts[i];
             SchemaGlobalElement head = elt.substitutionGroup();
 
-            if (head != null)
-            {
+            if (head != null) {
                 SchemaType headType = head.getType();
                 SchemaType tailType = elt.getType();
-                XmlObject parseTree = ((SchemaGlobalElementImpl)elt)._parseObject;
+                XmlObject parseTree = ((SchemaGlobalElementImpl) elt)._parseObject;
 
-                if (! headType.isAssignableFrom(tailType))
-                {
+                if (!headType.isAssignableFrom(tailType)) {
                     state.error(XmlErrorCodes.ELEM_PROPERTIES$SUBSTITUTION_VALID,
-                        new Object[] {QNameHelper.pretty(elt.getName()),
-                                      QNameHelper.pretty(head.getName())},
+                        new Object[]{QNameHelper.pretty(elt.getName()),
+                            QNameHelper.pretty(head.getName())},
                         parseTree);
-                }
-                else if (head.finalExtension() && head.finalRestriction())
-                {
+                } else if (head.finalExtension() && head.finalRestriction()) {
                     state.error(XmlErrorCodes.ELEM_PROPERTIES$SUBSTITUTION_FINAL,
-                        new Object[] {QNameHelper.pretty(elt.getName()),
-                                      QNameHelper.pretty(head.getName()),
-                                      "#all"}, parseTree);
-                }
-                else if (! headType.equals(tailType))
-                {
-                    if (head.finalExtension() && 
-                             tailType.getDerivationType() == SchemaType.DT_EXTENSION)
-                    {
+                        new Object[]{QNameHelper.pretty(elt.getName()),
+                            QNameHelper.pretty(head.getName()),
+                            "#all"}, parseTree);
+                } else if (!headType.equals(tailType)) {
+                    if (head.finalExtension() &&
+                        tailType.getDerivationType() == SchemaType.DT_EXTENSION) {
                         state.error(XmlErrorCodes.ELEM_PROPERTIES$SUBSTITUTION_FINAL,
-                            new Object[] {QNameHelper.pretty(elt.getName()),
-                                          QNameHelper.pretty(head.getName()),
-                                          "extension"}, parseTree);
-                    }
-                    else if (head.finalRestriction() &&
-                             tailType.getDerivationType() == SchemaType.DT_RESTRICTION)
-                    {
+                            new Object[]{QNameHelper.pretty(elt.getName()),
+                                QNameHelper.pretty(head.getName()),
+                                "extension"}, parseTree);
+                    } else if (head.finalRestriction() &&
+                               tailType.getDerivationType() == SchemaType.DT_RESTRICTION) {
                         state.error(XmlErrorCodes.ELEM_PROPERTIES$SUBSTITUTION_FINAL,
-                            new Object[] {QNameHelper.pretty(elt.getName()),
-                                          QNameHelper.pretty(head.getName()),
-                                          "restriction"}, parseTree);
+                            new Object[]{QNameHelper.pretty(elt.getName()),
+                                QNameHelper.pretty(head.getName()),
+                                "restriction"}, parseTree);
                     }
                 }
             }
diff --git a/src/main/java/org/apache/xmlbeans/impl/schema/StscResolver.java b/src/main/java/org/apache/xmlbeans/impl/schema/StscResolver.java
index 0c96d66..5a945e5 100644
--- a/src/main/java/org/apache/xmlbeans/impl/schema/StscResolver.java
+++ b/src/main/java/org/apache/xmlbeans/impl/schema/StscResolver.java
@@ -15,37 +15,31 @@
 
 package org.apache.xmlbeans.impl.schema;
 
-import org.apache.xmlbeans.SchemaType;
-import org.apache.xmlbeans.XmlObject;
-import org.apache.xmlbeans.SchemaParticle;
 import org.apache.xmlbeans.QNameSet;
+import org.apache.xmlbeans.SchemaParticle;
+import org.apache.xmlbeans.SchemaType;
 import org.apache.xmlbeans.XmlErrorCodes;
-
-import java.math.BigInteger;
-
-import java.util.*;
-
-import org.apache.xmlbeans.impl.xb.xsdschema.TopLevelElement;
-import org.apache.xmlbeans.impl.xb.xsdschema.TopLevelAttribute;
-import org.apache.xmlbeans.impl.xb.xsdschema.SimpleType;
 import org.apache.xmlbeans.impl.xb.xsdschema.Attribute;
 import org.apache.xmlbeans.impl.xb.xsdschema.Element;
 import org.apache.xmlbeans.impl.xb.xsdschema.KeyrefDocument.Keyref;
-import javax.xml.namespace.QName;
+import org.apache.xmlbeans.impl.xb.xsdschema.TopLevelElement;
 
-public class StscResolver
-{
+import javax.xml.namespace.QName;
+import java.math.BigInteger;
+import java.util.*;
+
+public class StscResolver {
     /**
      * Does a topo walk of all the types to resolve them.
      */
-    public static void resolveAll()
-    {
+    public static void resolveAll() {
         // resolve tree of types
         StscState state = StscState.get();
 
         SchemaType[] documentTypes = state.documentTypes();
-        for (int i = 0 ; i < documentTypes.length ; i++)
-            resolveSubstitutionGroup((SchemaTypeImpl)documentTypes[i]);
+        for (int i = 0; i < documentTypes.length; i++) {
+            resolveSubstitutionGroup((SchemaTypeImpl) documentTypes[i]);
+        }
 
         List allSeenTypes = new ArrayList();
         allSeenTypes.addAll(Arrays.asList(state.documentTypes()));
@@ -53,10 +47,9 @@
         allSeenTypes.addAll(Arrays.asList(state.redefinedGlobalTypes()));
         allSeenTypes.addAll(Arrays.asList(state.globalTypes()));
 
-        for (int i = 0; i < allSeenTypes.size(); i++)
-        {
-            SchemaType gType = (SchemaType)allSeenTypes.get(i);
-            resolveType((SchemaTypeImpl)gType);
+        for (int i = 0; i < allSeenTypes.size(); i++) {
+            SchemaType gType = (SchemaType) allSeenTypes.get(i);
+            resolveType((SchemaTypeImpl) gType);
             allSeenTypes.addAll(Arrays.asList(gType.getAnonymousTypes()));
         }
 
@@ -64,12 +57,11 @@
         resolveIdentityConstraints();
     }
 
-    public static boolean resolveType(SchemaTypeImpl sImpl)
-    {
-        if (sImpl.isResolved())
+    public static boolean resolveType(SchemaTypeImpl sImpl) {
+        if (sImpl.isResolved()) {
             return true;
-        if (sImpl.isResolving())
-        {
+        }
+        if (sImpl.isResolving()) {
             StscState.get().error("Cyclic dependency error", XmlErrorCodes.CYCLIC_DEPENDENCY, sImpl.getParseObject());
             return false; // cyclic dependency error
         }
@@ -77,28 +69,28 @@
 
         sImpl.startResolving();
 
-        if (sImpl.isDocumentType())
+        if (sImpl.isDocumentType()) {
             resolveDocumentType(sImpl);
-        else if (sImpl.isAttributeType())
+        } else if (sImpl.isAttributeType()) {
             resolveAttributeType(sImpl);
-        else if (sImpl.isSimpleType())
+        } else if (sImpl.isSimpleType()) {
             StscSimpleTypeResolver.resolveSimpleType(sImpl);
-        else
+        } else {
             StscComplexTypeResolver.resolveComplexType(sImpl);
+        }
 
         sImpl.finishResolving();
         // System.out.println("Finished resolving " + sImpl);
         return true;
     }
 
-    public static boolean resolveSubstitutionGroup(SchemaTypeImpl sImpl)
-    {
+    public static boolean resolveSubstitutionGroup(SchemaTypeImpl sImpl) {
         assert sImpl.isDocumentType();
 
-        if (sImpl.isSGResolved())
+        if (sImpl.isSGResolved()) {
             return true;
-        if (sImpl.isSGResolving())
-        {
+        }
+        if (sImpl.isSGResolving()) {
             StscState.get().error("Cyclic dependency error", XmlErrorCodes.CYCLIC_DEPENDENCY, sImpl.getParseObject());
             return false; // cyclic dependency error
         }
@@ -107,42 +99,44 @@
 
         // Resolve substitution group
 
-        TopLevelElement elt = (TopLevelElement)sImpl.getParseObject();
+        TopLevelElement elt = (TopLevelElement) sImpl.getParseObject();
         SchemaTypeImpl substitutionGroup = null;
         QName eltName = new QName(sImpl.getTargetNamespace(), elt.getName());
 
         // BUG: How do I tell if the type is in this compilation unit?
-        if (elt.isSetSubstitutionGroup())
-        {
-            substitutionGroup = StscState.get().findDocumentType(elt.getSubstitutionGroup(), 
+        if (elt.isSetSubstitutionGroup()) {
+            substitutionGroup = StscState.get().findDocumentType(elt.getSubstitutionGroup(),
                 sImpl.getChameleonNamespace(), sImpl.getTargetNamespace());
 
-            if (substitutionGroup == null)
+            if (substitutionGroup == null) {
                 StscState.get().notFoundError(elt.getSubstitutionGroup(), SchemaType.ELEMENT, elt.xgetSubstitutionGroup(), true);
-                // recovery - ignore substitution group
-            else if (! resolveSubstitutionGroup(substitutionGroup) )
+            }
+            // recovery - ignore substitution group
+            else if (!resolveSubstitutionGroup(substitutionGroup)) {
                 substitutionGroup = null;
-            else
+            } else {
                 sImpl.setSubstitutionGroup(elt.getSubstitutionGroup());
+            }
         }
 
         // Walk up the chain of subtitution groups adding this schematype to each head's
         // member list
-        while (substitutionGroup != null)
-        {
+        while (substitutionGroup != null) {
 
             substitutionGroup.addSubstitutionGroupMember(eltName);
 
-            if (substitutionGroup.getSubstitutionGroup() == null)
+            if (substitutionGroup.getSubstitutionGroup() == null) {
                 break;
+            }
 
             substitutionGroup = StscState.get().findDocumentType(
                 substitutionGroup.getSubstitutionGroup(), substitutionGroup.getChameleonNamespace(), null/*no dependency added*/);
 
             assert substitutionGroup != null : "Could not find document type for: " + substitutionGroup.getSubstitutionGroup();
 
-            if (! resolveSubstitutionGroup(substitutionGroup) )
+            if (!resolveSubstitutionGroup(substitutionGroup)) {
                 substitutionGroup = null; // cyclic dependency - no subst group
+            }
 
         }
 
@@ -151,150 +145,135 @@
 
     }
 
-    public static void resolveDocumentType ( SchemaTypeImpl sImpl )
-    {
+    public static void resolveDocumentType(SchemaTypeImpl sImpl) {
         assert sImpl.isResolving();
-        
+
         assert sImpl.isDocumentType();
-        
+
 
         // translate the global element associated with this document type
         // and construct a content model which allows just that element
-        
-        List anonTypes = new ArrayList();
+
+        List<SchemaType> anonTypes = new ArrayList<>();
 
         SchemaGlobalElementImpl element =
             (SchemaGlobalElementImpl)
                 StscTranslator.translateElement(
                     (Element) sImpl.getParseObject(),
                     sImpl.getTargetNamespace(), sImpl.isChameleon(), null, null,
-                    anonTypes, sImpl );
+                    anonTypes, sImpl);
 
         SchemaLocalElementImpl contentModel = null;
 
-        if (element != null)
-        {
-            StscState.get().addGlobalElement( element );
-                    
+        if (element != null) {
+            StscState.get().addGlobalElement(element);
+
             contentModel = new SchemaLocalElementImpl();
-        
-            contentModel.setParticleType( SchemaParticle.ELEMENT );
-            StscTranslator.copyGlobalElementToLocalElement( element, contentModel );
-            contentModel.setMinOccurs( BigInteger.ONE );
-            contentModel.setMaxOccurs( BigInteger.ONE );
+
+            contentModel.setParticleType(SchemaParticle.ELEMENT);
+            StscTranslator.copyGlobalElementToLocalElement(element, contentModel);
+            contentModel.setMinOccurs(BigInteger.ONE);
+            contentModel.setMaxOccurs(BigInteger.ONE);
 
             contentModel.setTransitionNotes(QNameSet.EMPTY, true);
         }
 
         Map elementPropertyModel =
             StscComplexTypeResolver.buildContentPropertyModelByQName(
-                contentModel, sImpl );
+                contentModel, sImpl);
 
         SchemaTypeImpl baseType = sImpl.getSubstitutionGroup() == null ?
             BuiltinSchemaTypeSystem.ST_ANY_TYPE :
-            StscState.get().findDocumentType(sImpl.getSubstitutionGroup(), 
-                sImpl.isChameleon() ? sImpl.getTargetNamespace() : null, null/*already added*/)
-            ;
+            StscState.get().findDocumentType(sImpl.getSubstitutionGroup(),
+                sImpl.isChameleon() ? sImpl.getTargetNamespace() : null, null/*already added*/);
 
-        sImpl.setBaseTypeRef( baseType.getRef() );
-        sImpl.setBaseDepth( baseType.getBaseDepth() + 1 );
-        sImpl.setDerivationType( SchemaType.DT_RESTRICTION );
-        sImpl.setComplexTypeVariety( SchemaType.ELEMENT_CONTENT );
+        sImpl.setBaseTypeRef(baseType.getRef());
+        sImpl.setBaseDepth(baseType.getBaseDepth() + 1);
+        sImpl.setDerivationType(SchemaType.DT_RESTRICTION);
+        sImpl.setComplexTypeVariety(SchemaType.ELEMENT_CONTENT);
 
         sImpl.setContentModel(
             contentModel, new SchemaAttributeModelImpl(),
-            elementPropertyModel, Collections.EMPTY_MAP, false );
-        
+            elementPropertyModel, Collections.EMPTY_MAP, false);
+
         sImpl.setWildcardSummary(
-            QNameSet.EMPTY, false, QNameSet.EMPTY, false );
+            QNameSet.EMPTY, false, QNameSet.EMPTY, false);
 
-        sImpl.setAnonymousTypeRefs( makeRefArray( anonTypes ) );
-
+        sImpl.setAnonymousTypeRefs(makeRefArray(anonTypes));
 
 
     }
-    
-    public static void resolveAttributeType ( SchemaTypeImpl sImpl )
-    {
+
+    public static void resolveAttributeType(SchemaTypeImpl sImpl) {
         assert sImpl.isResolving();
 
         assert sImpl.isAttributeType();
-        
-        List anonTypes = new ArrayList();
+
+        List<SchemaType> anonTypes = new ArrayList<>();
 
         SchemaGlobalAttributeImpl attribute =
             (SchemaGlobalAttributeImpl) StscTranslator.translateAttribute(
                 (Attribute) sImpl.getParseObject(), sImpl.getTargetNamespace(), null,
-                sImpl.isChameleon(), anonTypes, sImpl, null, false );
+                sImpl.isChameleon(), anonTypes, sImpl, null, false);
 
         SchemaAttributeModelImpl attributeModel = new SchemaAttributeModelImpl();
 
-        if (attribute != null)
-        {
-            StscState.get().addGlobalAttribute( attribute );
-            
+        if (attribute != null) {
+            StscState.get().addGlobalAttribute(attribute);
+
             SchemaLocalAttributeImpl attributeCopy = new SchemaLocalAttributeImpl();
-            StscTranslator.copyGlobalAttributeToLocalAttribute( attribute, attributeCopy );
-            attributeModel.addAttribute( attributeCopy );
+            StscTranslator.copyGlobalAttributeToLocalAttribute(attribute, attributeCopy);
+            attributeModel.addAttribute(attributeCopy);
         }
 
-        sImpl.setBaseTypeRef( BuiltinSchemaTypeSystem.ST_ANY_TYPE.getRef() );
-        sImpl.setBaseDepth( sImpl.getBaseDepth() + 1 );
-        sImpl.setDerivationType( SchemaType.DT_RESTRICTION );
-        sImpl.setComplexTypeVariety( SchemaType.EMPTY_CONTENT );
-        
+        sImpl.setBaseTypeRef(BuiltinSchemaTypeSystem.ST_ANY_TYPE.getRef());
+        sImpl.setBaseDepth(sImpl.getBaseDepth() + 1);
+        sImpl.setDerivationType(SchemaType.DT_RESTRICTION);
+        sImpl.setComplexTypeVariety(SchemaType.EMPTY_CONTENT);
+
         Map attributePropertyModel =
             StscComplexTypeResolver.buildAttributePropertyModelByQName(
-                attributeModel, sImpl );
+                attributeModel, sImpl);
 
         sImpl.setContentModel(
-            null, attributeModel, Collections.EMPTY_MAP, attributePropertyModel, false );
+            null, attributeModel, Collections.EMPTY_MAP, attributePropertyModel, false);
 
         sImpl.setWildcardSummary(
-            QNameSet.EMPTY, false, QNameSet.EMPTY, false );
-        
-        sImpl.setAnonymousTypeRefs( makeRefArray( anonTypes ) );
+            QNameSet.EMPTY, false, QNameSet.EMPTY, false);
+
+        sImpl.setAnonymousTypeRefs(makeRefArray(anonTypes));
     }
-    
-    private static SchemaType.Ref[] makeRefArray(Collection typeList)
-    {
-        SchemaType.Ref[] result = new SchemaType.Ref[typeList.size()];
-        int j = 0;
-        for (Iterator i = typeList.iterator(); i.hasNext(); j++)
-            result[j] = ((SchemaType)i.next()).getRef();
-        return result;
+
+    private static SchemaType.Ref[] makeRefArray(Collection<SchemaType> typeList) {
+        return typeList.stream().map(SchemaType::getRef).toArray(SchemaType.Ref[]::new);
     }
 
 
-    public static void resolveIdentityConstraints()
-    {
+    public static void resolveIdentityConstraints() {
         StscState state = StscState.get();
         SchemaIdentityConstraintImpl[] idcs = state.idConstraints();
 
-        for (int i = 0 ; i < idcs.length ; i++)
-        {
-            if (!idcs[i].isResolved())
-            {
-                Keyref xsdkr = (Keyref)idcs[i].getParseObject();
+        for (SchemaIdentityConstraintImpl idc : idcs) {
+            if (!idc.isResolved()) {
+                Keyref xsdkr = (Keyref) idc.getParseObject();
                 QName keyName = xsdkr.getRefer();
                 SchemaIdentityConstraintImpl key = null;
 
-                key = state.findIdConstraint(keyName, idcs[i].getChameleonNamespace(), idcs[i].getTargetNamespace());
-                if (key == null)
-                {
+                key = state.findIdConstraint(keyName, idc.getChameleonNamespace(), idc.getTargetNamespace());
+                if (key == null) {
                     state.notFoundError(keyName, SchemaType.IDENTITY_CONSTRAINT, xsdkr, true);
-                }
-                else 
-                {
-                    if (key.getConstraintCategory() == SchemaIdentityConstraintImpl.CC_KEYREF)
+                } else {
+                    if (key.getConstraintCategory() == SchemaIdentityConstraintImpl.CC_KEYREF) {
                         state.error(XmlErrorCodes.IDENTITY_CONSTRAINT_PROPERTIES$KEYREF_REFERS_TO_KEYREF,
-                            null, idcs[i].getParseObject());
+                            null, idc.getParseObject());
+                    }
 
-                    if (key.getFields().length != idcs[i].getFields().length)
+                    if (key.getFields().length != idc.getFields().length) {
                         state.error(XmlErrorCodes.IDENTITY_CONSTRAINT_PROPERTIES$KEY_KEYREF_FIELD_COUNT_EQ,
-                            null, idcs[i].getParseObject());
+                            null, idc.getParseObject());
+                    }
 
-                    idcs[i].setReferencedKey(key.getRef());
+                    idc.setReferencedKey(key.getRef());
                 }
             }
         }
diff --git a/src/main/java/org/apache/xmlbeans/impl/schema/StscState.java b/src/main/java/org/apache/xmlbeans/impl/schema/StscState.java
index 55c292d..b3ed068 100644
--- a/src/main/java/org/apache/xmlbeans/impl/schema/StscState.java
+++ b/src/main/java/org/apache/xmlbeans/impl/schema/StscState.java
@@ -31,17 +31,44 @@
 import java.net.URL;
 import java.nio.charset.StandardCharsets;
 import java.util.*;
+import java.util.function.Consumer;
 
 /**
  * This class represents the state of the SchemaTypeSystemCompiler as it's
  * going.
  */
 public class StscState {
+    private final static XmlValueRef XMLSTR_PRESERVE = buildString("preserve");
+    private final static XmlValueRef XMLSTR_REPLACE = buildString("preserve");
+    private final static XmlValueRef XMLSTR_COLLAPSE = buildString("preserve");
+
+    static final SchemaType[] EMPTY_ST_ARRAY = new SchemaType[0];
+
+    private static final XmlValueRef[] FACETS_NONE = new XmlValueRef[12];
+    private static final boolean[] FIXED_FACETS_NONE = new boolean[12];
+    private static final boolean[] FIXED_FACETS_WS = new boolean[12];
+
+    private static final XmlValueRef[] FACETS_WS_COLLAPSE = {
+        null, null, null, null, null, null, null, null, null,
+        build_wsstring(SchemaType.WS_COLLAPSE), null, null
+    };
+
+
+    final static XmlValueRef[] FACETS_UNION = FACETS_NONE;
+    final static boolean[] FIXED_FACETS_UNION = FIXED_FACETS_NONE;
+    final static XmlValueRef[] FACETS_LIST = FACETS_WS_COLLAPSE;
+    final static boolean[] FIXED_FACETS_LIST = FIXED_FACETS_WS;
+
+    private static final ThreadLocal<StscStack> tl_stscStack = new ThreadLocal<>();
+
+    private final static String PROJECT_URL_PREFIX = "project://local";
+
+
     private String _givenStsName;
-    private Collection _errorListener;
+    private Collection<XmlError> _errorListener;
     private SchemaTypeSystemImpl _target;
     private BindingConfig _config;
-    private Map _compatMap;
+    private Map<QName, QName> _compatMap;
     private boolean _doingDownloads;
     private byte[] _digest = null;
     private boolean _noDigest = false;
@@ -52,47 +79,45 @@
 
     private SchemaTypeLoader _importingLoader;
 
-    private Map _containers = new LinkedHashMap();
+    private final Map<String, SchemaContainer> _containers = new LinkedHashMap<>();
     private SchemaDependencies _dependencies;
 
     private Map _redefinedGlobalTypes = new LinkedHashMap();
     private Map _redefinedModelGroups = new LinkedHashMap();
     private Map _redefinedAttributeGroups = new LinkedHashMap();
 
-    private Map _globalTypes = new LinkedHashMap();
-    private Map _globalElements = new LinkedHashMap();
-    private Map _globalAttributes = new LinkedHashMap();
-    private Map _modelGroups = new LinkedHashMap();
-    private Map _attributeGroups = new LinkedHashMap();
-    private Map _documentTypes = new LinkedHashMap();
-    private Map _attributeTypes = new LinkedHashMap();
-    private Map _typesByClassname = new LinkedHashMap();
-    private Map _misspelledNames = new HashMap();
-    private Set _processingGroups = new LinkedHashSet();
-    private Map _idConstraints = new LinkedHashMap();
-    private Set _namespaces = new HashSet();
-    private List _annotations = new ArrayList();
+    private final Map<QName, SchemaType> _globalTypes = new LinkedHashMap<>();
+    private final Map<QName, SchemaGlobalElement> _globalElements = new LinkedHashMap<>();
+    private final Map<QName, SchemaGlobalAttribute> _globalAttributes = new LinkedHashMap<>();
+    private final Map<QName, SchemaModelGroup> _modelGroups = new LinkedHashMap<>();
+    private final Map<QName, SchemaAttributeGroup> _attributeGroups = new LinkedHashMap<>();
+    private final Map<QName, SchemaType> _documentTypes = new LinkedHashMap<>();
+    private final Map<QName, SchemaType> _attributeTypes = new LinkedHashMap<>();
+    private final Map<String, SchemaType> _typesByClassname = new LinkedHashMap<>();
+    private final Map<String, SchemaComponent> _misspelledNames = new HashMap<>();
+    private final Set<SchemaComponent> _processingGroups = new LinkedHashSet<>();
+    private final Map<QName, SchemaIdentityConstraint> _idConstraints = new LinkedHashMap<>();
+    private final Set<String> _namespaces = new HashSet<>();
+    private final List<SchemaAnnotation> _annotations = new ArrayList<>();
     private boolean _noUpa;
     private boolean _noPvr;
     private boolean _noAnn;
     private boolean _mdefAll;
-    private Set _mdefNamespaces = buildDefaultMdefNamespaces();
+    private final Set<String> _mdefNamespaces = buildDefaultMdefNamespaces();
     private EntityResolver _entityResolver;
     private File _schemasDir;
 
-    private static Set buildDefaultMdefNamespaces() {
-        // namespaces which are known to appear in WSDLs redundantly
-        return new HashSet(
-            Arrays.asList(new String[]{
-                "http://www.openuri.org/2002/04/soap/conversation/",
-            }));
-    }
 
-    /**
-     * Used to store the new target namespace for a chameleon
-     * included schema.
-     */
-    public static final Object CHAMELEON_INCLUDE_URI = new Object();
+    private final Map<String, String> _sourceForUri = new HashMap<>();
+    private URI _baseURI = URI.create(PROJECT_URL_PREFIX + "/");
+    private final SchemaTypeLoader _s4sloader = XmlBeans.typeLoaderForClassLoader(SchemaDocument.class.getClassLoader());
+
+
+    private static Set<String> buildDefaultMdefNamespaces() {
+        // namespaces which are known to appear in WSDLs redundantly
+        return new HashSet<>(
+            Collections.singletonList("http://www.openuri.org/2002/04/soap/conversation/"));
+    }
 
     /**
      * Only constructed via StscState.start().
@@ -103,14 +128,14 @@
     /**
      * Initializer for incremental compilation
      */
-    public void initFromTypeSystem(SchemaTypeSystemImpl system, Set newNamespaces) {
+    public void initFromTypeSystem(SchemaTypeSystemImpl system, Set<String> newNamespaces) {
 //         setGivenTypeSystemName(system.getName().substring(14));
 
         SchemaContainer[] containers = system.containers();
-        for (int i = 0; i < containers.length; i++) {
-            if (!newNamespaces.contains(containers[i].getNamespace())) {
+        for (SchemaContainer container : containers) {
+            if (!newNamespaces.contains(container.getNamespace())) {
                 // Copy data from the given container
-                addContainer(containers[i]);
+                addContainer(container);
             }
         }
     }
@@ -149,76 +174,37 @@
             _redefinedGlobalTypes.put(name, redefTypes.get(i));
         }
 
-        List globalElems = container.globalElements();
-        for (int i = 0; i < globalElems.size(); i++) {
-            QName name = ((SchemaGlobalElement) globalElems.get(i)).getName();
-            _globalElements.put(name, globalElems.get(i));
-        }
+        container.globalElements().forEach(g -> _globalElements.put(g.getName(), g));
+        container.globalAttributes().forEach(g -> _globalAttributes.put(g.getName(), g));
+        container.modelGroups().forEach(g -> _modelGroups.put(g.getName(), g));
+        container.attributeGroups().forEach(g -> _attributeGroups.put(g.getName(), g));
 
-        List globalAtts = container.globalAttributes();
-        for (int i = 0; i < globalAtts.size(); i++) {
-            QName name = ((SchemaGlobalAttribute) globalAtts.get(i)).getName();
-            _globalAttributes.put(name, globalAtts.get(i));
-        }
+        container.globalTypes().forEach(mapTypes(_globalTypes, false));
+        container.documentTypes().forEach(mapTypes(_documentTypes, true));
+        container.attributeTypes().forEach(mapTypes(_attributeTypes, true));
 
-        List modelGroups = container.modelGroups();
-        for (int i = 0; i < modelGroups.size(); i++) {
-            QName name = ((SchemaModelGroup) modelGroups.get(i)).getName();
-            _modelGroups.put(name, modelGroups.get(i));
-        }
-
-        List attrGroups = container.attributeGroups();
-        for (int i = 0; i < attrGroups.size(); i++) {
-            QName name = ((SchemaAttributeGroup) attrGroups.get(i)).getName();
-            _attributeGroups.put(name, attrGroups.get(i));
-        }
-
-        List globalTypes = container.globalTypes();
-        for (int i = 0; i < globalTypes.size(); i++) {
-            SchemaType t = (SchemaType) globalTypes.get(i);
-            QName name = t.getName();
-            _globalTypes.put(name, t);
-            if (t.getFullJavaName() != null) {
-                addClassname(t.getFullJavaName(), t);
-            }
-        }
-
-        List documentTypes = container.documentTypes();
-        for (int i = 0; i < documentTypes.size(); i++) {
-            SchemaType t = (SchemaType) documentTypes.get(i);
-            QName name = t.getProperties()[0].getName();
-            _documentTypes.put(name, t);
-            if (t.getFullJavaName() != null) {
-                addClassname(t.getFullJavaName(), t);
-            }
-        }
-
-        List attributeTypes = container.attributeTypes();
-        for (int i = 0; i < attributeTypes.size(); i++) {
-            SchemaType t = (SchemaType) attributeTypes.get(i);
-            QName name = t.getProperties()[0].getName();
-            _attributeTypes.put(name, t);
-            if (t.getFullJavaName() != null) {
-                addClassname(t.getFullJavaName(), t);
-            }
-        }
-
-        List identityConstraints = container.identityConstraints();
-        for (int i = 0; i < identityConstraints.size(); i++) {
-            QName name = ((SchemaIdentityConstraint) identityConstraints.get(i)).getName();
-            _idConstraints.put(name, identityConstraints.get(i));
-        }
+        container.identityConstraints().forEach(g -> _idConstraints.put(g.getName(), g));
 
         _annotations.addAll(container.annotations());
         _namespaces.add(container.getNamespace());
         container.unsetImmutable();
     }
 
-    SchemaContainer getContainer(String namespace) {
-        return (SchemaContainer) _containers.get(namespace);
+    private Consumer<SchemaType> mapTypes(Map<QName, SchemaType> map, boolean useProperties) {
+        return (t) -> {
+            QName name = useProperties ? t.getProperties()[0].getName() : t.getName();
+            map.put(name, t);
+            if (t.getFullJavaName() != null) {
+                addClassname(t.getFullJavaName(), t);
+            }
+        };
     }
 
-    Map getContainerMap() {
+    SchemaContainer getContainer(String namespace) {
+        return _containers.get(namespace);
+    }
+
+    Map<String, SchemaContainer> getContainerMap() {
         return Collections.unmodifiableMap(_containers);
     }
 
@@ -255,7 +241,7 @@
     /**
      * Initializer for error handling.
      */
-    public void setErrorListener(Collection errorListener) {
+    public void setErrorListener(Collection<XmlError> errorListener) {
         _errorListener = errorListener;
     }
 
@@ -318,7 +304,7 @@
     }
 
     // KHK: remove this
-    public static void addError(Collection errorListener, String message, int code, XmlObject location) {
+    public static void addError(Collection<XmlError> errorListener, String message, int code, XmlObject location) {
         XmlError err =
             XmlError.forObject(
                 message,
@@ -327,7 +313,7 @@
         errorListener.add(err);
     }
 
-    public static void addError(Collection errorListener, String code, Object[] args, XmlObject location) {
+    public static void addError(Collection<XmlError> errorListener, String code, Object[] args, XmlObject location) {
         XmlError err =
             XmlError.forObject(
                 code,
@@ -337,7 +323,7 @@
         errorListener.add(err);
     }
 
-    public static void addError(Collection errorListener, String code, Object[] args, File location) {
+    public static void addError(Collection<XmlError> errorListener, String code, Object[] args, File location) {
         XmlError err =
             XmlError.forLocation(
                 code,
@@ -347,7 +333,7 @@
         errorListener.add(err);
     }
 
-    public static void addError(Collection errorListener, String code, Object[] args, URL location) {
+    public static void addError(Collection<XmlError> errorListener, String code, Object[] args, URL location) {
         XmlError err =
             XmlError.forLocation(
                 code,
@@ -358,7 +344,7 @@
     }
 
     // KHK: remove this
-    public static void addWarning(Collection errorListener, String message, int code, XmlObject location) {
+    public static void addWarning(Collection<XmlError> errorListener, String message, int code, XmlObject location) {
         XmlError err =
             XmlError.forObject(
                 message,
@@ -367,7 +353,7 @@
         errorListener.add(err);
     }
 
-    public static void addWarning(Collection errorListener, String code, Object[] args, XmlObject location) {
+    public static void addWarning(Collection<XmlError> errorListener, String code, Object[] args, XmlObject location) {
         XmlError err =
             XmlError.forObject(
                 code,
@@ -377,12 +363,12 @@
         errorListener.add(err);
     }
 
-    public static void addInfo(Collection errorListener, String message) {
+    public static void addInfo(Collection<XmlError> errorListener, String message) {
         XmlError err = XmlError.forMessage(message, XmlError.SEVERITY_INFO);
         errorListener.add(err);
     }
 
-    public static void addInfo(Collection errorListener, String code, Object[] args) {
+    public static void addInfo(Collection<XmlError> errorListener, String code, Object[] args) {
         XmlError err = XmlError.forMessage(code, args, XmlError.SEVERITY_INFO);
         errorListener.add(err);
     }
@@ -574,7 +560,7 @@
             return name;
         }
 
-        QName subst = (QName) _compatMap.get(name);
+        QName subst = _compatMap.get(name);
         if (subst == null) {
             return name;
         }
@@ -646,7 +632,7 @@
     }
 
     SchemaComponent findSpelling(QName name) {
-        return (SchemaComponent) _misspelledNames.get(crunchName(name));
+        return _misspelledNames.get(crunchName(name));
     }
 
     /* NAMESPACES ======================================================*/
@@ -656,7 +642,7 @@
     }
 
     String[] getNamespaces() {
-        return (String[]) _namespaces.toArray(new String[_namespaces.size()]);
+        return _namespaces.toArray(new String[0]);
     }
 
     boolean linkerDefinesNamespace(String namespace) {
@@ -722,11 +708,11 @@
                     if (!ignoreMdef(name)) {
                         if (_mdefAll) {
                             warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
-                                new Object[]{"global type", QNameHelper.pretty(name), ((SchemaType) _globalTypes.get(name)).getSourceName()},
+                                new Object[]{"global type", QNameHelper.pretty(name), _globalTypes.get(name).getSourceName()},
                                 type.getParseObject());
                         } else {
                             error(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
-                                new Object[]{"global type", QNameHelper.pretty(name), ((SchemaType) _globalTypes.get(name)).getSourceName()},
+                                new Object[]{"global type", QNameHelper.pretty(name), _globalTypes.get(name).getSourceName()},
                                 type.getParseObject());
                         }
                     }
@@ -744,11 +730,11 @@
     }
 
     SchemaType[] globalTypes() {
-        return (SchemaType[]) _globalTypes.values().toArray(new SchemaType[_globalTypes.size()]);
+        return _globalTypes.values().toArray(new SchemaType[0]);
     }
 
     SchemaType[] redefinedGlobalTypes() {
-        return (SchemaType[]) _redefinedGlobalTypes.values().toArray(new SchemaType[_redefinedGlobalTypes.size()]);
+        return (SchemaType[]) _redefinedGlobalTypes.values().toArray(new SchemaType[0]);
     }
 
     /* DOCUMENT TYPES =================================================*/
@@ -772,11 +758,11 @@
             if (!ignoreMdef(name)) {
                 if (_mdefAll) {
                     warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
-                        new Object[]{"global element", QNameHelper.pretty(name), ((SchemaComponent) _documentTypes.get(name)).getSourceName()},
+                        new Object[]{"global element", QNameHelper.pretty(name), _documentTypes.get(name).getSourceName()},
                         type.getParseObject());
                 } else {
                     error(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
-                        new Object[]{"global element", QNameHelper.pretty(name), ((SchemaComponent) _documentTypes.get(name)).getSourceName()},
+                        new Object[]{"global element", QNameHelper.pretty(name), _documentTypes.get(name).getSourceName()},
                         type.getParseObject());
                 }
             }
@@ -789,7 +775,7 @@
     }
 
     SchemaType[] documentTypes() {
-        return (SchemaType[]) _documentTypes.values().toArray(new SchemaType[_documentTypes.size()]);
+        return _documentTypes.values().toArray(new SchemaType[0]);
     }
 
     /* ATTRIBUTE TYPES =================================================*/
@@ -813,11 +799,11 @@
             if (!ignoreMdef(name)) {
                 if (_mdefAll) {
                     warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
-                        new Object[]{"global attribute", QNameHelper.pretty(name), ((SchemaComponent) _attributeTypes.get(name)).getSourceName()},
+                        new Object[]{"global attribute", QNameHelper.pretty(name), _attributeTypes.get(name).getSourceName()},
                         type.getParseObject());
                 } else {
                     error(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
-                        new Object[]{"global attribute", QNameHelper.pretty(name), ((SchemaComponent) _attributeTypes.get(name)).getSourceName()},
+                        new Object[]{"global attribute", QNameHelper.pretty(name), _attributeTypes.get(name).getSourceName()},
                         type.getParseObject());
                 }
             }
@@ -830,7 +816,7 @@
     }
 
     SchemaType[] attributeTypes() {
-        return (SchemaType[]) _attributeTypes.values().toArray(new SchemaType[_attributeTypes.size()]);
+        return _attributeTypes.values().toArray(new SchemaType[0]);
     }
 
     /* ATTRIBUTES =====================================================*/
@@ -861,7 +847,7 @@
     }
 
     SchemaGlobalAttribute[] globalAttributes() {
-        return (SchemaGlobalAttribute[]) _globalAttributes.values().toArray(new SchemaGlobalAttribute[_globalAttributes.size()]);
+        return _globalAttributes.values().toArray(new SchemaGlobalAttribute[0]);
     }
 
     /* ELEMENTS =======================================================*/
@@ -892,7 +878,7 @@
     }
 
     SchemaGlobalElement[] globalElements() {
-        return (SchemaGlobalElement[]) _globalElements.values().toArray(new SchemaGlobalElement[_globalElements.size()]);
+        return _globalElements.values().toArray(new SchemaGlobalElement[0]);
     }
 
     /* ATTRIBUTE GROUPS ===============================================*/
@@ -952,11 +938,11 @@
                     if (!ignoreMdef(name)) {
                         if (_mdefAll) {
                             warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
-                                new Object[]{"attribute group", QNameHelper.pretty(name), ((SchemaComponent) _attributeGroups.get(name)).getSourceName()},
+                                new Object[]{"attribute group", QNameHelper.pretty(name), _attributeGroups.get(name).getSourceName()},
                                 attributeGroup.getParseObject());
                         } else {
                             error(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
-                                new Object[]{"attribute group", QNameHelper.pretty(name), ((SchemaComponent) _attributeGroups.get(name)).getSourceName()},
+                                new Object[]{"attribute group", QNameHelper.pretty(name), _attributeGroups.get(name).getSourceName()},
                                 attributeGroup.getParseObject());
                         }
                     }
@@ -970,11 +956,11 @@
     }
 
     SchemaAttributeGroup[] attributeGroups() {
-        return (SchemaAttributeGroup[]) _attributeGroups.values().toArray(new SchemaAttributeGroup[_attributeGroups.size()]);
+        return _attributeGroups.values().toArray(new SchemaAttributeGroup[0]);
     }
 
     SchemaAttributeGroup[] redefinedAttributeGroups() {
-        return (SchemaAttributeGroup[]) _redefinedAttributeGroups.values().toArray(new SchemaAttributeGroup[_redefinedAttributeGroups.size()]);
+        return (SchemaAttributeGroup[]) _redefinedAttributeGroups.values().toArray(new SchemaAttributeGroup[0]);
     }
 
     /* MODEL GROUPS ===================================================*/
@@ -1034,11 +1020,11 @@
                     if (!ignoreMdef(name)) {
                         if (_mdefAll) {
                             warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
-                                new Object[]{"model group", QNameHelper.pretty(name), ((SchemaComponent) _modelGroups.get(name)).getSourceName()},
+                                new Object[]{"model group", QNameHelper.pretty(name), _modelGroups.get(name).getSourceName()},
                                 modelGroup.getParseObject());
                         } else {
                             error(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
-                                new Object[]{"model group", QNameHelper.pretty(name), ((SchemaComponent) _modelGroups.get(name)).getSourceName()},
+                                new Object[]{"model group", QNameHelper.pretty(name), _modelGroups.get(name).getSourceName()},
                                 modelGroup.getParseObject());
                         }
                     }
@@ -1052,11 +1038,11 @@
     }
 
     SchemaModelGroup[] modelGroups() {
-        return (SchemaModelGroup[]) _modelGroups.values().toArray(new SchemaModelGroup[_modelGroups.size()]);
+        return _modelGroups.values().toArray(new SchemaModelGroup[0]);
     }
 
     SchemaModelGroup[] redefinedModelGroups() {
-        return (SchemaModelGroup[]) _redefinedModelGroups.values().toArray(new SchemaModelGroup[_redefinedModelGroups.size()]);
+        return (SchemaModelGroup[]) _redefinedModelGroups.values().toArray(new SchemaModelGroup[0]);
     }
 
     /* IDENTITY CONSTRAINTS ===========================================*/
@@ -1077,7 +1063,7 @@
             if (_idConstraints.containsKey(name)) {
                 if (!ignoreMdef(name)) {
                     warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
-                        new Object[]{"identity constraint", QNameHelper.pretty(name), ((SchemaComponent) _idConstraints.get(name)).getSourceName()},
+                        new Object[]{"identity constraint", QNameHelper.pretty(name), _idConstraints.get(name).getSourceName()},
                         idc.getParseObject());
                 }
             } else {
@@ -1089,7 +1075,7 @@
     }
 
     SchemaIdentityConstraintImpl[] idConstraints() {
-        return (SchemaIdentityConstraintImpl[]) _idConstraints.values().toArray(new SchemaIdentityConstraintImpl[_idConstraints.size()]);
+        return _idConstraints.values().toArray(new SchemaIdentityConstraintImpl[0]);
     }
 
     /* ANNOTATIONS ===========================================*/
@@ -1103,32 +1089,32 @@
         }
     }
 
-    List annotations() {
+    List<SchemaAnnotation> annotations() {
         return _annotations;
     }
 
     /* RECURSION AVOIDANCE ============================================*/
-    boolean isProcessing(Object obj) {
+    boolean isProcessing(SchemaComponent obj) {
         return _processingGroups.contains(obj);
     }
 
-    void startProcessing(Object obj) {
+    void startProcessing(SchemaComponent obj) {
         assert (!_processingGroups.contains(obj));
         _processingGroups.add(obj);
     }
 
-    void finishProcessing(Object obj) {
+    void finishProcessing(SchemaComponent obj) {
         assert (_processingGroups.contains(obj));
         _processingGroups.remove(obj);
     }
 
-    Object[] getCurrentProcessing() {
-        return _processingGroups.toArray();
+    SchemaComponent[] getCurrentProcessing() {
+        return _processingGroups.toArray(new SchemaComponent[0]);
     }
 
     /* JAVAIZATION ====================================================*/
 
-    Map typesByClassname() {
+    Map<String, SchemaType> typesByClassname() {
         return Collections.unmodifiableMap(_typesByClassname);
     }
 
@@ -1143,7 +1129,7 @@
      */
     private static final class StscStack {
         StscState current;
-        ArrayList stack = new ArrayList();
+        List<StscState> stack = new ArrayList<>();
 
         final StscState push() {
             stack.add(current);
@@ -1152,19 +1138,17 @@
         }
 
         final void pop() {
-            current = (StscState) stack.get(stack.size() - 1);
+            current = stack.get(stack.size() - 1);
             stack.remove(stack.size() - 1);
         }
     }
 
-    private static ThreadLocal tl_stscStack = new ThreadLocal();
-
     public static void clearThreadLocals() {
         tl_stscStack.remove();
     }
 
     public static StscState start() {
-        StscStack stscStack = (StscStack) tl_stscStack.get();
+        StscStack stscStack = tl_stscStack.get();
 
         if (stscStack == null) {
             stscStack = new StscStack();
@@ -1174,11 +1158,11 @@
     }
 
     public static StscState get() {
-        return ((StscStack) tl_stscStack.get()).current;
+        return tl_stscStack.get().current;
     }
 
     public static void end() {
-        StscStack stscStack = (StscStack) tl_stscStack.get();
+        StscStack stscStack = tl_stscStack.get();
         stscStack.pop();
         if (stscStack.stack.size() == 0) {
             tl_stscStack.set(null);            // this is required to release all the references in this classloader
@@ -1186,33 +1170,6 @@
         // which will enable class unloading and avoid OOM in PermGen
     }
 
-    private final static XmlValueRef XMLSTR_PRESERVE = buildString("preserve");
-    private final static XmlValueRef XMLSTR_REPLACE = buildString("preserve");
-    private final static XmlValueRef XMLSTR_COLLAPSE = buildString("preserve");
-
-    static final SchemaType[] EMPTY_ST_ARRAY = new SchemaType[0];
-    static final SchemaType.Ref[] EMPTY_STREF_ARRAY = new SchemaType.Ref[0];
-
-    private final static XmlValueRef[] FACETS_NONE = new XmlValueRef[]
-        {null, null, null, null, null, null, null, null, null,
-            null, null, null};
-
-    private final static boolean[] FIXED_FACETS_NONE = new boolean[]
-        {false, false, false, false, false, false, false, false, false,
-            false, false, false};
-
-    private final static XmlValueRef[] FACETS_WS_COLLAPSE = new XmlValueRef[]
-        {null, null, null, null, null, null, null, null, null,
-            build_wsstring(SchemaType.WS_COLLAPSE), null, null};
-
-    private final static boolean[] FIXED_FACETS_WS = new boolean[]
-        {false, false, false, false, false, false, false, false, false,
-            true, false, false};
-
-    final static XmlValueRef[] FACETS_UNION = FACETS_NONE;
-    final static boolean[] FIXED_FACETS_UNION = FIXED_FACETS_NONE;
-    final static XmlValueRef[] FACETS_LIST = FACETS_WS_COLLAPSE;
-    final static boolean[] FIXED_FACETS_LIST = FIXED_FACETS_WS;
 
     static XmlValueRef build_wsstring(int wsr) {
         switch (wsr) {
@@ -1285,15 +1242,15 @@
                 switch (foundComponent.getComponentType()) {
                     case SchemaComponent.TYPE:
                         found = "type";
-                        sourceName = ((SchemaType) foundComponent).getSourceName();
+                        sourceName = foundComponent.getSourceName();
                         break;
                     case SchemaComponent.ELEMENT:
                         found = "element";
-                        sourceName = ((SchemaGlobalElement) foundComponent).getSourceName();
+                        sourceName = foundComponent.getSourceName();
                         break;
                     case SchemaComponent.ATTRIBUTE:
                         found = "attribute";
-                        sourceName = ((SchemaGlobalAttribute) foundComponent).getSourceName();
+                        sourceName = foundComponent.getSourceName();
                         break;
                     case SchemaComponent.ATTRIBUTE_GROUP:
                         found = "attribute group";
@@ -1341,7 +1298,7 @@
      * Returns null if none.
      */
     public String sourceNameForUri(String uri) {
-        return (String) _sourceForUri.get(uri);
+        return _sourceForUri.get(uri);
     }
 
     /**
@@ -1349,7 +1306,7 @@
      * been read to "sourceName" local names that have been used
      * to tag the types.
      */
-    public Map sourceCopyMap() {
+    public Map<String, String> sourceCopyMap() {
         return Collections.unmodifiableMap(_sourceForUri);
     }
 
@@ -1360,8 +1317,6 @@
         _baseURI = uri;
     }
 
-    private final static String PROJECT_URL_PREFIX = "project://local";
-
     public String relativize(String uri) {
         return relativize(uri, false);
     }
@@ -1411,7 +1366,7 @@
             return dir + "/" + uri.substring(lastslash + 1);
         }
 
-        String query = QNameHelper.hexsafe(question == -1 ? "" : uri.substring(question));
+        String query = QNameHelper.hexsafe(uri.substring(question));
 
         // if encoded query part is longer than 64 characters, just drop it
         if (query.startsWith(QNameHelper.URI_SHA1_PREFIX)) {
@@ -1440,7 +1395,7 @@
     /**
      * Returns the error listener being filled in during this compilation
      */
-    public Collection getErrorListener() {
+    public Collection<XmlError> getErrorListener() {
         return _errorListener;
     }
 
@@ -1451,10 +1406,6 @@
         return _s4sloader;
     }
 
-    Map _sourceForUri = new HashMap();
-    URI _baseURI = URI.create(PROJECT_URL_PREFIX + "/");
-    SchemaTypeLoader _s4sloader = XmlBeans.typeLoaderForClassLoader(SchemaDocument.class.getClassLoader());
-
     public File getSchemasDir() {
         return _schemasDir;
     }