docs: protected void record( final MethodDeclaration method,
                             final Node parentNode ) throws Exception {
          final String name = method.getName().getFullyQualifiedName();
          final Node methodNode = parentNode.addNode(name, ClassFileSequencerLexicon.METHOD);
          methodNode.setProperty(ClassFileSequencerLexicon.NAME, name);
  
          { // javadocs
              final Javadoc javadoc = method.getJavadoc();
  
              if (javadoc != null) {
                  record(javadoc, methodNode);
              }
          }
  
          { // type parameters
              @SuppressWarnings( "unchecked" )
              final List<TypeParameter> typeParams = method.typeParameters();
  
              if ((typeParams != null) && !typeParams.isEmpty()) {
                  final Node containerNode = methodNode.addNode(ClassFileSequencerLexicon.TYPE_PARAMETERS,
                                                                ClassFileSequencerLexicon.TYPE_PARAMETERS);
  
                  for (final TypeParameter param : typeParams) {
                      record(param, containerNode);
                  }
              }
          }
  
          { // modifiers
              final int modifiers = method.getModifiers();
  
              methodNode.setProperty(ClassFileSequencerLexicon.ABSTRACT, (modifiers & Modifier.ABSTRACT) != 0);
              methodNode.setProperty(ClassFileSequencerLexicon.FINAL, (modifiers & Modifier.FINAL) != 0);
              methodNode.setProperty(ClassFileSequencerLexicon.NATIVE, (modifiers & Modifier.NATIVE) != 0);
              methodNode.setProperty(ClassFileSequencerLexicon.STATIC, (modifiers & Modifier.STATIC) != 0);
              methodNode.setProperty(ClassFileSequencerLexicon.STRICT_FP, (modifiers & Modifier.STRICTFP) != 0);
              methodNode.setProperty(ClassFileSequencerLexicon.SYNCHRONIZED, (modifiers & Modifier.SYNCHRONIZED) != 0);
              methodNode.setProperty(ClassFileSequencerLexicon.VISIBILITY, getVisibility(modifiers));
          }
  
          { // annotations
              @SuppressWarnings( "unchecked" )
              final List<IExtendedModifier> modifiers = method.modifiers();
              recordAnnotations(modifiers, methodNode);
          }
  
          { // parameters
              @SuppressWarnings( "unchecked" )
              final List<SingleVariableDeclaration> params = method.parameters();
  
              if ((params != null) && !params.isEmpty()) {
                  final Node containerNode = methodNode.addNode(ClassFileSequencerLexicon.METHOD_PARAMETERS,
                                                                ClassFileSequencerLexicon.PARAMETERS);
  
                  for (final SingleVariableDeclaration param : params) {
                      record(param, containerNode);
                  }
              }
          }
  
          { // return type
              if (method.isConstructor()) {
                  methodNode.setProperty(ClassFileSequencerLexicon.RETURN_TYPE_CLASS_NAME, Void.TYPE.getCanonicalName());
              } else {
                  final Type returnType = method.getReturnType2();
                  methodNode.setProperty(ClassFileSequencerLexicon.RETURN_TYPE_CLASS_NAME, getTypeName(returnType));
                  record(returnType, ClassFileSequencerLexicon.RETURN_TYPE, methodNode);
              }
          }
  
          { // thrown exceptions
              @SuppressWarnings( "unchecked" )
              final List<Name> errors = method.thrownExceptions();
  
              if ((errors != null) && !errors.isEmpty()) {
                  final String[] errorNames = new String[errors.size()];
                  int i = 0;
  
                  for (final Name error : errors) {
                      errorNames[i++] = error.getFullyQualifiedName();
                  }
  
                  methodNode.setProperty(ClassFileSequencerLexicon.THROWN_EXCEPTIONS, errorNames);
              }
          }
  
          { // body
              final Block body = method.getBody();
  
              if ((body != null) && (body.statements() != null) && !body.statements().isEmpty()) {
                  final Node bodyNode = methodNode.addNode(ClassFileSequencerLexicon.BODY, ClassFileSequencerLexicon.STATEMENTS);
                  record(body, bodyNode);
              }
          }
  
          recordSourceReference(method, methodNode);
      }