docs: def collectMastersForGlyph(self, glyphName, decomposeComponents=False):
          """ Return a glyph mutator.defaultLoc
              decomposeComponents = True causes the source glyphs to be decomposed first
              before building the mutator. That gives you instances that do not depend
              on a complete font. If you're calculating previews for instance.
  
              XXX check glyphs in layers
          """
          items = []
          empties = []
          foundEmpty = False
          for sourceDescriptor in self.sources:
              if not os.path.exists(sourceDescriptor.path):
                  #kthxbai
                  p = "\tMissing UFO at %s" % sourceDescriptor.path
                  if p not in self.problems:
                      self.problems.append(p)
                  continue
              if glyphName in sourceDescriptor.mutedGlyphNames:
                  continue
              thisIsDefault = self.default == sourceDescriptor
              ignoreMaster, filteredLocation = self.filterThisLocation(sourceDescriptor.location, self.mutedAxisNames)
              if ignoreMaster:
                  continue
              f = self.fonts.get(sourceDescriptor.name)
              if f is None: continue
              loc = Location(sourceDescriptor.location)
              sourceLayer = f
              if not glyphName in f:
                  # log this>
                  continue
              layerName = getDefaultLayerName(f)
              sourceGlyphObject = None
              # handle source layers
              if sourceDescriptor.layerName is not None:
                  # start looking for a layer
                  # Do not bother for mutatorMath designspaces
                  layerName = sourceDescriptor.layerName
                  sourceLayer = getLayer(f, sourceDescriptor.layerName)
                  if sourceLayer is None:
                      continue
                  if glyphName not in sourceLayer:
                      # start looking for a glyph
                      # this might be a support in a sparse layer
                      # so we're skipping!
                      continue
              # still have to check if the sourcelayer glyph is empty
              if not glyphName in sourceLayer:
                  continue
              else:
                  sourceGlyphObject = sourceLayer[glyphName]
                  if checkGlyphIsEmpty(sourceGlyphObject, allowWhiteSpace=True):
                      foundEmpty = True
                      #sourceGlyphObject = None
                      #continue
              if decomposeComponents:
                  # what about decomposing glyphs in a partial font?
                  temp = self.glyphClass()
                  p = temp.getPointPen()
                  dpp = DecomposePointPen(sourceLayer, p)
                  sourceGlyphObject.drawPoints(dpp)
                  temp.width = sourceGlyphObject.width
                  temp.name = sourceGlyphObject.name
                  processThis = temp
              else:
                  processThis = sourceGlyphObject
              sourceInfo = dict(source=f.path, glyphName=glyphName,
                      layerName=layerName,
                      location=filteredLocation,  #   sourceDescriptor.location,
                      sourceName=sourceDescriptor.name,
                      )
              if hasattr(processThis, "toMathGlyph"):
                  processThis = processThis.toMathGlyph()
              else:
                  processThis = self.mathGlyphClass(processThis)
              items.append((loc, processThis, sourceInfo))
              empties.append((thisIsDefault, foundEmpty))
          # check the empties:
          # if the default glyph is empty, then all must be empty
          # if the default glyph is not empty then none can be empty
          checkedItems = []
          emptiesAllowed = False
          # first check if the default is empty.
          # remember that the sources can be in any order
          for i, p in enumerate(empties):
              isDefault, isEmpty = p
              if isDefault and isEmpty:
                  emptiesAllowed = True
                  # now we know what to look for
          if not emptiesAllowed:
              for i, p in enumerate(empties):
                  isDefault, isEmpty = p
                  if not isEmpty:
                      checkedItems.append(items[i])
          else:
              for i, p in enumerate(empties):
                  isDefault, isEmpty = p
                  if isEmpty:
                      checkedItems.append(items[i])
          return checkedItems